using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text.RegularExpressions;
namespace ServiceStack
{
	public static class StringUtils
	{
		private static readonly Regex StripHtmlUnicodeRegEx = new Regex("&(#)?([xX])?([^ \\f\\n\\r\\t\\v;]+);", RegexOptions.Compiled);
		public static readonly IDictionary<string, string> HtmlCharacterCodes = new SortedDictionary<string, string>
		{

			{
				"&Aacute;",
				193.ToChar()
			},

			{
				"&aacute;",
				225.ToChar()
			},

			{
				"&Abreve;",
				258.ToChar()
			},

			{
				"&abreve;",
				259.ToChar()
			},

			{
				"&ac;",
				8766.ToChar()
			},

			{
				"&acd;",
				8767.ToChar()
			},

			{
				"&acE;",
				8766.ToChar()
			},

			{
				"&Acirc;",
				194.ToChar()
			},

			{
				"&acirc;",
				226.ToChar()
			},

			{
				"&acute;",
				180.ToChar()
			},

			{
				"&Acy;",
				1040.ToChar()
			},

			{
				"&acy;",
				1072.ToChar()
			},

			{
				"&AElig;",
				198.ToChar()
			},

			{
				"&aelig;",
				230.ToChar()
			},

			{
				"&af;",
				8289.ToChar()
			},

			{
				"&Agrave;",
				192.ToChar()
			},

			{
				"&agrave;",
				224.ToChar()
			},

			{
				"&alefsym;",
				8501.ToChar()
			},

			{
				"&aleph;",
				8501.ToChar()
			},

			{
				"&Alpha;",
				913.ToChar()
			},

			{
				"&alpha;",
				945.ToChar()
			},

			{
				"&Amacr;",
				256.ToChar()
			},

			{
				"&amacr;",
				257.ToChar()
			},

			{
				"&amalg;",
				10815.ToChar()
			},

			{
				"&AMP;",
				38.ToChar()
			},

			{
				"&amp;",
				38.ToChar()
			},

			{
				"&And;",
				10835.ToChar()
			},

			{
				"&and;",
				8743.ToChar()
			},

			{
				"&andand;",
				10837.ToChar()
			},

			{
				"&andd;",
				10844.ToChar()
			},

			{
				"&andslope;",
				10840.ToChar()
			},

			{
				"&andv;",
				10842.ToChar()
			},

			{
				"&ang;",
				8736.ToChar()
			},

			{
				"&ange;",
				10660.ToChar()
			},

			{
				"&angle;",
				8736.ToChar()
			},

			{
				"&angmsd;",
				8737.ToChar()
			},

			{
				"&angmsdaa;",
				10664.ToChar()
			},

			{
				"&angmsdab;",
				10665.ToChar()
			},

			{
				"&angmsdac;",
				10666.ToChar()
			},

			{
				"&angmsdad;",
				10667.ToChar()
			},

			{
				"&angmsdae;",
				10668.ToChar()
			},

			{
				"&angmsdaf;",
				10669.ToChar()
			},

			{
				"&angmsdag;",
				10670.ToChar()
			},

			{
				"&angmsdah;",
				10671.ToChar()
			},

			{
				"&angrt;",
				8735.ToChar()
			},

			{
				"&angrtvb;",
				8894.ToChar()
			},

			{
				"&angrtvbd;",
				10653.ToChar()
			},

			{
				"&angsph;",
				8738.ToChar()
			},

			{
				"&angst;",
				197.ToChar()
			},

			{
				"&angzarr;",
				9084.ToChar()
			},

			{
				"&Aogon;",
				260.ToChar()
			},

			{
				"&aogon;",
				261.ToChar()
			},

			{
				"&ap;",
				8776.ToChar()
			},

			{
				"&apacir;",
				10863.ToChar()
			},

			{
				"&apE;",
				10864.ToChar()
			},

			{
				"&ape;",
				8778.ToChar()
			},

			{
				"&apid;",
				8779.ToChar()
			},

			{
				"&apos;",
				39.ToChar()
			},

			{
				"&ApplyFunction;",
				8289.ToChar()
			},

			{
				"&approx;",
				8776.ToChar()
			},

			{
				"&approxeq;",
				8778.ToChar()
			},

			{
				"&Aring;",
				197.ToChar()
			},

			{
				"&aring;",
				229.ToChar()
			},

			{
				"&Assign;",
				8788.ToChar()
			},

			{
				"&ast;",
				42.ToChar()
			},

			{
				"&asymp;",
				8776.ToChar()
			},

			{
				"&asympeq;",
				8781.ToChar()
			},

			{
				"&Atilde;",
				195.ToChar()
			},

			{
				"&atilde;",
				227.ToChar()
			},

			{
				"&Auml;",
				196.ToChar()
			},

			{
				"&auml;",
				228.ToChar()
			},

			{
				"&awconint;",
				8755.ToChar()
			},

			{
				"&awint;",
				10769.ToChar()
			},

			{
				"&backcong;",
				8780.ToChar()
			},

			{
				"&backepsilon;",
				1014.ToChar()
			},

			{
				"&backprime;",
				8245.ToChar()
			},

			{
				"&backsim;",
				8765.ToChar()
			},

			{
				"&backsimeq;",
				8909.ToChar()
			},

			{
				"&Backslash;",
				8726.ToChar()
			},

			{
				"&Barv;",
				10983.ToChar()
			},

			{
				"&barvee;",
				8893.ToChar()
			},

			{
				"&Barwed;",
				8966.ToChar()
			},

			{
				"&barwed;",
				8965.ToChar()
			},

			{
				"&barwedge;",
				8965.ToChar()
			},

			{
				"&bbrk;",
				9141.ToChar()
			},

			{
				"&bbrktbrk;",
				9142.ToChar()
			},

			{
				"&bcong;",
				8780.ToChar()
			},

			{
				"&Bcy;",
				1041.ToChar()
			},

			{
				"&bcy;",
				1073.ToChar()
			},

			{
				"&bdquo;",
				8222.ToChar()
			},

			{
				"&becaus;",
				8757.ToChar()
			},

			{
				"&Because;",
				8757.ToChar()
			},

			{
				"&because;",
				8757.ToChar()
			},

			{
				"&bemptyv;",
				10672.ToChar()
			},

			{
				"&bepsi;",
				1014.ToChar()
			},

			{
				"&bernou;",
				8492.ToChar()
			},

			{
				"&Bernoullis;",
				8492.ToChar()
			},

			{
				"&Beta;",
				914.ToChar()
			},

			{
				"&beta;",
				946.ToChar()
			},

			{
				"&beth;",
				8502.ToChar()
			},

			{
				"&between;",
				8812.ToChar()
			},

			{
				"&bigcap;",
				8898.ToChar()
			},

			{
				"&bigcirc;",
				9711.ToChar()
			},

			{
				"&bigcup;",
				8899.ToChar()
			},

			{
				"&bigodot;",
				10752.ToChar()
			},

			{
				"&bigoplus;",
				10753.ToChar()
			},

			{
				"&bigotimes;",
				10754.ToChar()
			},

			{
				"&bigsqcup;",
				10758.ToChar()
			},

			{
				"&bigstar;",
				9733.ToChar()
			},

			{
				"&bigtriangledown;",
				9661.ToChar()
			},

			{
				"&bigtriangleup;",
				9651.ToChar()
			},

			{
				"&biguplus;",
				10756.ToChar()
			},

			{
				"&bigvee;",
				8897.ToChar()
			},

			{
				"&bigwedge;",
				8896.ToChar()
			},

			{
				"&bkarow;",
				10509.ToChar()
			},

			{
				"&blacklozenge;",
				10731.ToChar()
			},

			{
				"&blacksquare;",
				9642.ToChar()
			},

			{
				"&blacktriangle;",
				9652.ToChar()
			},

			{
				"&blacktriangledown;",
				9662.ToChar()
			},

			{
				"&blacktriangleleft;",
				9666.ToChar()
			},

			{
				"&blacktriangleright;",
				9656.ToChar()
			},

			{
				"&blank;",
				9251.ToChar()
			},

			{
				"&blk12;",
				9618.ToChar()
			},

			{
				"&blk14;",
				9617.ToChar()
			},

			{
				"&blk34;",
				9619.ToChar()
			},

			{
				"&block;",
				9608.ToChar()
			},

			{
				"&bne;",
				61.ToChar()
			},

			{
				"&bnequiv;",
				8801.ToChar()
			},

			{
				"&bNot;",
				10989.ToChar()
			},

			{
				"&bnot;",
				8976.ToChar()
			},

			{
				"&bot;",
				8869.ToChar()
			},

			{
				"&bottom;",
				8869.ToChar()
			},

			{
				"&bowtie;",
				8904.ToChar()
			},

			{
				"&boxbox;",
				10697.ToChar()
			},

			{
				"&boxDL;",
				9559.ToChar()
			},

			{
				"&boxDl;",
				9558.ToChar()
			},

			{
				"&boxdL;",
				9557.ToChar()
			},

			{
				"&boxdl;",
				9488.ToChar()
			},

			{
				"&boxDR;",
				9556.ToChar()
			},

			{
				"&boxDr;",
				9555.ToChar()
			},

			{
				"&boxdR;",
				9554.ToChar()
			},

			{
				"&boxdr;",
				9484.ToChar()
			},

			{
				"&boxH;",
				9552.ToChar()
			},

			{
				"&boxh;",
				9472.ToChar()
			},

			{
				"&boxHD;",
				9574.ToChar()
			},

			{
				"&boxHd;",
				9572.ToChar()
			},

			{
				"&boxhD;",
				9573.ToChar()
			},

			{
				"&boxhd;",
				9516.ToChar()
			},

			{
				"&boxHU;",
				9577.ToChar()
			},

			{
				"&boxHu;",
				9575.ToChar()
			},

			{
				"&boxhU;",
				9576.ToChar()
			},

			{
				"&boxhu;",
				9524.ToChar()
			},

			{
				"&boxminus;",
				8863.ToChar()
			},

			{
				"&boxplus;",
				8862.ToChar()
			},

			{
				"&boxtimes;",
				8864.ToChar()
			},

			{
				"&boxUL;",
				9565.ToChar()
			},

			{
				"&boxUl;",
				9564.ToChar()
			},

			{
				"&boxuL;",
				9563.ToChar()
			},

			{
				"&boxul;",
				9496.ToChar()
			},

			{
				"&boxUR;",
				9562.ToChar()
			},

			{
				"&boxUr;",
				9561.ToChar()
			},

			{
				"&boxuR;",
				9560.ToChar()
			},

			{
				"&boxur;",
				9492.ToChar()
			},

			{
				"&boxV;",
				9553.ToChar()
			},

			{
				"&boxv;",
				9474.ToChar()
			},

			{
				"&boxVH;",
				9580.ToChar()
			},

			{
				"&boxVh;",
				9579.ToChar()
			},

			{
				"&boxvH;",
				9578.ToChar()
			},

			{
				"&boxvh;",
				9532.ToChar()
			},

			{
				"&boxVL;",
				9571.ToChar()
			},

			{
				"&boxVl;",
				9570.ToChar()
			},

			{
				"&boxvL;",
				9569.ToChar()
			},

			{
				"&boxvl;",
				9508.ToChar()
			},

			{
				"&boxVR;",
				9568.ToChar()
			},

			{
				"&boxVr;",
				9567.ToChar()
			},

			{
				"&boxvR;",
				9566.ToChar()
			},

			{
				"&boxvr;",
				9500.ToChar()
			},

			{
				"&bprime;",
				8245.ToChar()
			},

			{
				"&Breve;",
				728.ToChar()
			},

			{
				"&breve;",
				728.ToChar()
			},

			{
				"&brvbar;",
				166.ToChar()
			},

			{
				"&Bscr;",
				8492.ToChar()
			},

			{
				"&bsemi;",
				8271.ToChar()
			},

			{
				"&bsim;",
				8765.ToChar()
			},

			{
				"&bsime;",
				8909.ToChar()
			},

			{
				"&bsol;",
				92.ToChar()
			},

			{
				"&bsolb;",
				10693.ToChar()
			},

			{
				"&bsolhsub;",
				10184.ToChar()
			},

			{
				"&bull;",
				8226.ToChar()
			},

			{
				"&bullet;",
				8226.ToChar()
			},

			{
				"&bump;",
				8782.ToChar()
			},

			{
				"&bumpE;",
				10926.ToChar()
			},

			{
				"&bumpe;",
				8783.ToChar()
			},

			{
				"&Bumpeq;",
				8782.ToChar()
			},

			{
				"&bumpeq;",
				8783.ToChar()
			},

			{
				"&Cacute;",
				262.ToChar()
			},

			{
				"&cacute;",
				263.ToChar()
			},

			{
				"&Cap;",
				8914.ToChar()
			},

			{
				"&cap;",
				8745.ToChar()
			},

			{
				"&capand;",
				10820.ToChar()
			},

			{
				"&capbrcup;",
				10825.ToChar()
			},

			{
				"&capcap;",
				10827.ToChar()
			},

			{
				"&capcup;",
				10823.ToChar()
			},

			{
				"&capdot;",
				10816.ToChar()
			},

			{
				"&CapitalDifferentialD;",
				8517.ToChar()
			},

			{
				"&caps;",
				8745.ToChar()
			},

			{
				"&caret;",
				8257.ToChar()
			},

			{
				"&caron;",
				711.ToChar()
			},

			{
				"&Cayleys;",
				8493.ToChar()
			},

			{
				"&ccaps;",
				10829.ToChar()
			},

			{
				"&Ccaron;",
				268.ToChar()
			},

			{
				"&ccaron;",
				269.ToChar()
			},

			{
				"&Ccedil;",
				199.ToChar()
			},

			{
				"&ccedil;",
				231.ToChar()
			},

			{
				"&Ccirc;",
				264.ToChar()
			},

			{
				"&ccirc;",
				265.ToChar()
			},

			{
				"&Cconint;",
				8752.ToChar()
			},

			{
				"&ccups;",
				10828.ToChar()
			},

			{
				"&ccupssm;",
				10832.ToChar()
			},

			{
				"&Cdot;",
				266.ToChar()
			},

			{
				"&cdot;",
				267.ToChar()
			},

			{
				"&cedil;",
				184.ToChar()
			},

			{
				"&Cedilla;",
				184.ToChar()
			},

			{
				"&cemptyv;",
				10674.ToChar()
			},

			{
				"&cent;",
				162.ToChar()
			},

			{
				"&CenterDot;",
				183.ToChar()
			},

			{
				"&centerdot;",
				183.ToChar()
			},

			{
				"&Cfr;",
				8493.ToChar()
			},

			{
				"&CHcy;",
				1063.ToChar()
			},

			{
				"&chcy;",
				1095.ToChar()
			},

			{
				"&check;",
				10003.ToChar()
			},

			{
				"&checkmark;",
				10003.ToChar()
			},

			{
				"&Chi;",
				935.ToChar()
			},

			{
				"&chi;",
				967.ToChar()
			},

			{
				"&cir;",
				9675.ToChar()
			},

			{
				"&circ;",
				710.ToChar()
			},

			{
				"&circeq;",
				8791.ToChar()
			},

			{
				"&circlearrowleft;",
				8634.ToChar()
			},

			{
				"&circlearrowright;",
				8635.ToChar()
			},

			{
				"&circledast;",
				8859.ToChar()
			},

			{
				"&circledcirc;",
				8858.ToChar()
			},

			{
				"&circleddash;",
				8861.ToChar()
			},

			{
				"&CircleDot;",
				8857.ToChar()
			},

			{
				"&circledR;",
				174.ToChar()
			},

			{
				"&circledS;",
				9416.ToChar()
			},

			{
				"&CircleMinus;",
				8854.ToChar()
			},

			{
				"&CirclePlus;",
				8853.ToChar()
			},

			{
				"&CircleTimes;",
				8855.ToChar()
			},

			{
				"&cirE;",
				10691.ToChar()
			},

			{
				"&cire;",
				8791.ToChar()
			},

			{
				"&cirfnint;",
				10768.ToChar()
			},

			{
				"&cirmid;",
				10991.ToChar()
			},

			{
				"&cirscir;",
				10690.ToChar()
			},

			{
				"&ClockwiseContourIntegral;",
				8754.ToChar()
			},

			{
				"&CloseCurlyDoubleQuote;",
				8221.ToChar()
			},

			{
				"&CloseCurlyQuote;",
				8217.ToChar()
			},

			{
				"&clubs;",
				9827.ToChar()
			},

			{
				"&clubsuit;",
				9827.ToChar()
			},

			{
				"&Colon;",
				8759.ToChar()
			},

			{
				"&colon;",
				58.ToChar()
			},

			{
				"&Colone;",
				10868.ToChar()
			},

			{
				"&colone;",
				8788.ToChar()
			},

			{
				"&coloneq;",
				8788.ToChar()
			},

			{
				"&comma;",
				44.ToChar()
			},

			{
				"&commat;",
				64.ToChar()
			},

			{
				"&comp;",
				8705.ToChar()
			},

			{
				"&compfn;",
				8728.ToChar()
			},

			{
				"&complement;",
				8705.ToChar()
			},

			{
				"&complexes;",
				8450.ToChar()
			},

			{
				"&cong;",
				8773.ToChar()
			},

			{
				"&congdot;",
				10861.ToChar()
			},

			{
				"&Congruent;",
				8801.ToChar()
			},

			{
				"&Conint;",
				8751.ToChar()
			},

			{
				"&conint;",
				8750.ToChar()
			},

			{
				"&ContourIntegral;",
				8750.ToChar()
			},

			{
				"&Copf;",
				8450.ToChar()
			},

			{
				"&coprod;",
				8720.ToChar()
			},

			{
				"&Coproduct;",
				8720.ToChar()
			},

			{
				"&COPY;",
				169.ToChar()
			},

			{
				"&copy;",
				169.ToChar()
			},

			{
				"&copysr;",
				8471.ToChar()
			},

			{
				"&CounterClockwiseContourIntegral;",
				8755.ToChar()
			},

			{
				"&crarr;",
				8629.ToChar()
			},

			{
				"&Cross;",
				10799.ToChar()
			},

			{
				"&cross;",
				10007.ToChar()
			},

			{
				"&csub;",
				10959.ToChar()
			},

			{
				"&csube;",
				10961.ToChar()
			},

			{
				"&csup;",
				10960.ToChar()
			},

			{
				"&csupe;",
				10962.ToChar()
			},

			{
				"&ctdot;",
				8943.ToChar()
			},

			{
				"&cudarrl;",
				10552.ToChar()
			},

			{
				"&cudarrr;",
				10549.ToChar()
			},

			{
				"&cuepr;",
				8926.ToChar()
			},

			{
				"&cuesc;",
				8927.ToChar()
			},

			{
				"&cularr;",
				8630.ToChar()
			},

			{
				"&cularrp;",
				10557.ToChar()
			},

			{
				"&Cup;",
				8915.ToChar()
			},

			{
				"&cup;",
				8746.ToChar()
			},

			{
				"&cupbrcap;",
				10824.ToChar()
			},

			{
				"&CupCap;",
				8781.ToChar()
			},

			{
				"&cupcap;",
				10822.ToChar()
			},

			{
				"&cupcup;",
				10826.ToChar()
			},

			{
				"&cupdot;",
				8845.ToChar()
			},

			{
				"&cupor;",
				10821.ToChar()
			},

			{
				"&cups;",
				8746.ToChar()
			},

			{
				"&curarr;",
				8631.ToChar()
			},

			{
				"&curarrm;",
				10556.ToChar()
			},

			{
				"&curlyeqprec;",
				8926.ToChar()
			},

			{
				"&curlyeqsucc;",
				8927.ToChar()
			},

			{
				"&curlyvee;",
				8910.ToChar()
			},

			{
				"&curlywedge;",
				8911.ToChar()
			},

			{
				"&curren;",
				164.ToChar()
			},

			{
				"&curvearrowleft;",
				8630.ToChar()
			},

			{
				"&curvearrowright;",
				8631.ToChar()
			},

			{
				"&cuvee;",
				8910.ToChar()
			},

			{
				"&cuwed;",
				8911.ToChar()
			},

			{
				"&cwconint;",
				8754.ToChar()
			},

			{
				"&cwint;",
				8753.ToChar()
			},

			{
				"&cylcty;",
				9005.ToChar()
			},

			{
				"&Dagger;",
				8225.ToChar()
			},

			{
				"&dagger;",
				8224.ToChar()
			},

			{
				"&daleth;",
				8504.ToChar()
			},

			{
				"&Darr;",
				8609.ToChar()
			},

			{
				"&dArr;",
				8659.ToChar()
			},

			{
				"&darr;",
				8595.ToChar()
			},

			{
				"&dash;",
				8208.ToChar()
			},

			{
				"&Dashv;",
				10980.ToChar()
			},

			{
				"&dashv;",
				8867.ToChar()
			},

			{
				"&dbkarow;",
				10511.ToChar()
			},

			{
				"&dblac;",
				733.ToChar()
			},

			{
				"&Dcaron;",
				270.ToChar()
			},

			{
				"&dcaron;",
				271.ToChar()
			},

			{
				"&Dcy;",
				1044.ToChar()
			},

			{
				"&dcy;",
				1076.ToChar()
			},

			{
				"&DD;",
				8517.ToChar()
			},

			{
				"&dd;",
				8518.ToChar()
			},

			{
				"&ddagger;",
				8225.ToChar()
			},

			{
				"&ddarr;",
				8650.ToChar()
			},

			{
				"&DDotrahd;",
				10513.ToChar()
			},

			{
				"&ddotseq;",
				10871.ToChar()
			},

			{
				"&deg;",
				176.ToChar()
			},

			{
				"&Del;",
				8711.ToChar()
			},

			{
				"&Delta;",
				916.ToChar()
			},

			{
				"&delta;",
				948.ToChar()
			},

			{
				"&demptyv;",
				10673.ToChar()
			},

			{
				"&dfisht;",
				10623.ToChar()
			},

			{
				"&dHar;",
				10597.ToChar()
			},

			{
				"&dharl;",
				8643.ToChar()
			},

			{
				"&dharr;",
				8642.ToChar()
			},

			{
				"&DiacriticalAcute;",
				180.ToChar()
			},

			{
				"&DiacriticalDot;",
				729.ToChar()
			},

			{
				"&DiacriticalDoubleAcute;",
				733.ToChar()
			},

			{
				"&DiacriticalGrave;",
				96.ToChar()
			},

			{
				"&DiacriticalTilde;",
				732.ToChar()
			},

			{
				"&diam;",
				8900.ToChar()
			},

			{
				"&Diamond;",
				8900.ToChar()
			},

			{
				"&diamond;",
				8900.ToChar()
			},

			{
				"&diamondsuit;",
				9830.ToChar()
			},

			{
				"&diams;",
				9830.ToChar()
			},

			{
				"&die;",
				168.ToChar()
			},

			{
				"&DifferentialD;",
				8518.ToChar()
			},

			{
				"&digamma;",
				989.ToChar()
			},

			{
				"&disin;",
				8946.ToChar()
			},

			{
				"&div;",
				247.ToChar()
			},

			{
				"&divide;",
				247.ToChar()
			},

			{
				"&divideontimes;",
				8903.ToChar()
			},

			{
				"&divonx;",
				8903.ToChar()
			},

			{
				"&DJcy;",
				1026.ToChar()
			},

			{
				"&djcy;",
				1106.ToChar()
			},

			{
				"&dlcorn;",
				8990.ToChar()
			},

			{
				"&dlcrop;",
				8973.ToChar()
			},

			{
				"&dollar;",
				36.ToChar()
			},

			{
				"&Dot;",
				168.ToChar()
			},

			{
				"&dot;",
				729.ToChar()
			},

			{
				"&DotDot;",
				8412.ToChar()
			},

			{
				"&doteq;",
				8784.ToChar()
			},

			{
				"&doteqdot;",
				8785.ToChar()
			},

			{
				"&DotEqual;",
				8784.ToChar()
			},

			{
				"&dotminus;",
				8760.ToChar()
			},

			{
				"&dotplus;",
				8724.ToChar()
			},

			{
				"&dotsquare;",
				8865.ToChar()
			},

			{
				"&doublebarwedge;",
				8966.ToChar()
			},

			{
				"&DoubleContourIntegral;",
				8751.ToChar()
			},

			{
				"&DoubleDot;",
				168.ToChar()
			},

			{
				"&DoubleDownArrow;",
				8659.ToChar()
			},

			{
				"&DoubleLeftArrow;",
				8656.ToChar()
			},

			{
				"&DoubleLeftRightArrow;",
				8660.ToChar()
			},

			{
				"&DoubleLeftTee;",
				10980.ToChar()
			},

			{
				"&DoubleLongLeftArrow;",
				10232.ToChar()
			},

			{
				"&DoubleLongLeftRightArrow;",
				10234.ToChar()
			},

			{
				"&DoubleLongRightArrow;",
				10233.ToChar()
			},

			{
				"&DoubleRightArrow;",
				8658.ToChar()
			},

			{
				"&DoubleRightTee;",
				8872.ToChar()
			},

			{
				"&DoubleUpArrow;",
				8657.ToChar()
			},

			{
				"&DoubleUpDownArrow;",
				8661.ToChar()
			},

			{
				"&DoubleVerticalBar;",
				8741.ToChar()
			},

			{
				"&DownArrow;",
				8595.ToChar()
			},

			{
				"&Downarrow;",
				8659.ToChar()
			},

			{
				"&downarrow;",
				8595.ToChar()
			},

			{
				"&DownArrowBar;",
				10515.ToChar()
			},

			{
				"&DownArrowUpArrow;",
				8693.ToChar()
			},

			{
				"&DownBreve;",
				785.ToChar()
			},

			{
				"&downdownarrows;",
				8650.ToChar()
			},

			{
				"&downharpoonleft;",
				8643.ToChar()
			},

			{
				"&downharpoonright;",
				8642.ToChar()
			},

			{
				"&DownLeftRightVector;",
				10576.ToChar()
			},

			{
				"&DownLeftTeeVector;",
				10590.ToChar()
			},

			{
				"&DownLeftVector;",
				8637.ToChar()
			},

			{
				"&DownLeftVectorBar;",
				10582.ToChar()
			},

			{
				"&DownRightTeeVector;",
				10591.ToChar()
			},

			{
				"&DownRightVector;",
				8641.ToChar()
			},

			{
				"&DownRightVectorBar;",
				10583.ToChar()
			},

			{
				"&DownTee;",
				8868.ToChar()
			},

			{
				"&DownTeeArrow;",
				8615.ToChar()
			},

			{
				"&drbkarow;",
				10512.ToChar()
			},

			{
				"&drcorn;",
				8991.ToChar()
			},

			{
				"&drcrop;",
				8972.ToChar()
			},

			{
				"&DScy;",
				1029.ToChar()
			},

			{
				"&dscy;",
				1109.ToChar()
			},

			{
				"&dsol;",
				10742.ToChar()
			},

			{
				"&Dstrok;",
				272.ToChar()
			},

			{
				"&dstrok;",
				273.ToChar()
			},

			{
				"&dtdot;",
				8945.ToChar()
			},

			{
				"&dtri;",
				9663.ToChar()
			},

			{
				"&dtrif;",
				9662.ToChar()
			},

			{
				"&duarr;",
				8693.ToChar()
			},

			{
				"&duhar;",
				10607.ToChar()
			},

			{
				"&dwangle;",
				10662.ToChar()
			},

			{
				"&DZcy;",
				1039.ToChar()
			},

			{
				"&dzcy;",
				1119.ToChar()
			},

			{
				"&dzigrarr;",
				10239.ToChar()
			},

			{
				"&Eacute;",
				201.ToChar()
			},

			{
				"&eacute;",
				233.ToChar()
			},

			{
				"&easter;",
				10862.ToChar()
			},

			{
				"&Ecaron;",
				282.ToChar()
			},

			{
				"&ecaron;",
				283.ToChar()
			},

			{
				"&ecir;",
				8790.ToChar()
			},

			{
				"&Ecirc;",
				202.ToChar()
			},

			{
				"&ecirc;",
				234.ToChar()
			},

			{
				"&ecolon;",
				8789.ToChar()
			},

			{
				"&Ecy;",
				1069.ToChar()
			},

			{
				"&ecy;",
				1101.ToChar()
			},

			{
				"&eDDot;",
				10871.ToChar()
			},

			{
				"&Edot;",
				278.ToChar()
			},

			{
				"&eDot;",
				8785.ToChar()
			},

			{
				"&edot;",
				279.ToChar()
			},

			{
				"&ee;",
				8519.ToChar()
			},

			{
				"&efDot;",
				8786.ToChar()
			},

			{
				"&eg;",
				10906.ToChar()
			},

			{
				"&Egrave;",
				200.ToChar()
			},

			{
				"&egrave;",
				232.ToChar()
			},

			{
				"&egs;",
				10902.ToChar()
			},

			{
				"&egsdot;",
				10904.ToChar()
			},

			{
				"&el;",
				10905.ToChar()
			},

			{
				"&Element;",
				8712.ToChar()
			},

			{
				"&elinters;",
				9191.ToChar()
			},

			{
				"&ell;",
				8467.ToChar()
			},

			{
				"&els;",
				10901.ToChar()
			},

			{
				"&elsdot;",
				10903.ToChar()
			},

			{
				"&Emacr;",
				274.ToChar()
			},

			{
				"&emacr;",
				275.ToChar()
			},

			{
				"&empty;",
				8709.ToChar()
			},

			{
				"&emptyset;",
				8709.ToChar()
			},

			{
				"&EmptySmallSquare;",
				9723.ToChar()
			},

			{
				"&emptyv;",
				8709.ToChar()
			},

			{
				"&EmptyVerySmallSquare;",
				9643.ToChar()
			},

			{
				"&emsp;",
				8195.ToChar()
			},

			{
				"&emsp13;",
				8196.ToChar()
			},

			{
				"&emsp14;",
				8197.ToChar()
			},

			{
				"&ENG;",
				330.ToChar()
			},

			{
				"&eng;",
				331.ToChar()
			},

			{
				"&ensp;",
				8194.ToChar()
			},

			{
				"&Eogon;",
				280.ToChar()
			},

			{
				"&eogon;",
				281.ToChar()
			},

			{
				"&epar;",
				8917.ToChar()
			},

			{
				"&eparsl;",
				10723.ToChar()
			},

			{
				"&eplus;",
				10865.ToChar()
			},

			{
				"&epsi;",
				949.ToChar()
			},

			{
				"&Epsilon;",
				917.ToChar()
			},

			{
				"&epsilon;",
				949.ToChar()
			},

			{
				"&epsiv;",
				1013.ToChar()
			},

			{
				"&eqcirc;",
				8790.ToChar()
			},

			{
				"&eqcolon;",
				8789.ToChar()
			},

			{
				"&eqsim;",
				8770.ToChar()
			},

			{
				"&eqslantgtr;",
				10902.ToChar()
			},

			{
				"&eqslantless;",
				10901.ToChar()
			},

			{
				"&Equal;",
				10869.ToChar()
			},

			{
				"&equals;",
				61.ToChar()
			},

			{
				"&EqualTilde;",
				8770.ToChar()
			},

			{
				"&equest;",
				8799.ToChar()
			},

			{
				"&Equilibrium;",
				8652.ToChar()
			},

			{
				"&equiv;",
				8801.ToChar()
			},

			{
				"&equivDD;",
				10872.ToChar()
			},

			{
				"&eqvparsl;",
				10725.ToChar()
			},

			{
				"&erarr;",
				10609.ToChar()
			},

			{
				"&erDot;",
				8787.ToChar()
			},

			{
				"&Escr;",
				8496.ToChar()
			},

			{
				"&escr;",
				8495.ToChar()
			},

			{
				"&esdot;",
				8784.ToChar()
			},

			{
				"&Esim;",
				10867.ToChar()
			},

			{
				"&esim;",
				8770.ToChar()
			},

			{
				"&Eta;",
				919.ToChar()
			},

			{
				"&eta;",
				951.ToChar()
			},

			{
				"&ETH;",
				208.ToChar()
			},

			{
				"&eth;",
				240.ToChar()
			},

			{
				"&Euml;",
				203.ToChar()
			},

			{
				"&euml;",
				235.ToChar()
			},

			{
				"&euro;",
				8364.ToChar()
			},

			{
				"&excl;",
				33.ToChar()
			},

			{
				"&exist;",
				8707.ToChar()
			},

			{
				"&Exists;",
				8707.ToChar()
			},

			{
				"&expectation;",
				8496.ToChar()
			},

			{
				"&ExponentialE;",
				8519.ToChar()
			},

			{
				"&exponentiale;",
				8519.ToChar()
			},

			{
				"&fallingdotseq;",
				8786.ToChar()
			},

			{
				"&Fcy;",
				1060.ToChar()
			},

			{
				"&fcy;",
				1092.ToChar()
			},

			{
				"&female;",
				9792.ToChar()
			},

			{
				"&ffilig;",
				64259.ToChar()
			},

			{
				"&fflig;",
				64256.ToChar()
			},

			{
				"&ffllig;",
				64260.ToChar()
			},

			{
				"&filig;",
				64257.ToChar()
			},

			{
				"&FilledSmallSquare;",
				9724.ToChar()
			},

			{
				"&FilledVerySmallSquare;",
				9642.ToChar()
			},

			{
				"&fjlig;",
				102.ToChar()
			},

			{
				"&flat;",
				9837.ToChar()
			},

			{
				"&fllig;",
				64258.ToChar()
			},

			{
				"&fltns;",
				9649.ToChar()
			},

			{
				"&fnof;",
				402.ToChar()
			},

			{
				"&ForAll;",
				8704.ToChar()
			},

			{
				"&forall;",
				8704.ToChar()
			},

			{
				"&fork;",
				8916.ToChar()
			},

			{
				"&forkv;",
				10969.ToChar()
			},

			{
				"&Fouriertrf;",
				8497.ToChar()
			},

			{
				"&fpartint;",
				10765.ToChar()
			},

			{
				"&frac12;",
				189.ToChar()
			},

			{
				"&frac13;",
				8531.ToChar()
			},

			{
				"&frac14;",
				188.ToChar()
			},

			{
				"&frac15;",
				8533.ToChar()
			},

			{
				"&frac16;",
				8537.ToChar()
			},

			{
				"&frac18;",
				8539.ToChar()
			},

			{
				"&frac23;",
				8532.ToChar()
			},

			{
				"&frac25;",
				8534.ToChar()
			},

			{
				"&frac34;",
				190.ToChar()
			},

			{
				"&frac35;",
				8535.ToChar()
			},

			{
				"&frac38;",
				8540.ToChar()
			},

			{
				"&frac45;",
				8536.ToChar()
			},

			{
				"&frac56;",
				8538.ToChar()
			},

			{
				"&frac58;",
				8541.ToChar()
			},

			{
				"&frac78;",
				8542.ToChar()
			},

			{
				"&frasl;",
				8260.ToChar()
			},

			{
				"&frown;",
				8994.ToChar()
			},

			{
				"&Fscr;",
				8497.ToChar()
			},

			{
				"&gacute;",
				501.ToChar()
			},

			{
				"&Gamma;",
				915.ToChar()
			},

			{
				"&gamma;",
				947.ToChar()
			},

			{
				"&Gammad;",
				988.ToChar()
			},

			{
				"&gammad;",
				989.ToChar()
			},

			{
				"&gap;",
				10886.ToChar()
			},

			{
				"&Gbreve;",
				286.ToChar()
			},

			{
				"&gbreve;",
				287.ToChar()
			},

			{
				"&Gcedil;",
				290.ToChar()
			},

			{
				"&Gcirc;",
				284.ToChar()
			},

			{
				"&gcirc;",
				285.ToChar()
			},

			{
				"&Gcy;",
				1043.ToChar()
			},

			{
				"&gcy;",
				1075.ToChar()
			},

			{
				"&Gdot;",
				288.ToChar()
			},

			{
				"&gdot;",
				289.ToChar()
			},

			{
				"&gE;",
				8807.ToChar()
			},

			{
				"&ge;",
				8805.ToChar()
			},

			{
				"&gEl;",
				10892.ToChar()
			},

			{
				"&gel;",
				8923.ToChar()
			},

			{
				"&geq;",
				8805.ToChar()
			},

			{
				"&geqq;",
				8807.ToChar()
			},

			{
				"&geqslant;",
				10878.ToChar()
			},

			{
				"&ges;",
				10878.ToChar()
			},

			{
				"&gescc;",
				10921.ToChar()
			},

			{
				"&gesdot;",
				10880.ToChar()
			},

			{
				"&gesdoto;",
				10882.ToChar()
			},

			{
				"&gesdotol;",
				10884.ToChar()
			},

			{
				"&gesl;",
				8923.ToChar()
			},

			{
				"&gesles;",
				10900.ToChar()
			},

			{
				"&Gg;",
				8921.ToChar()
			},

			{
				"&gg;",
				8811.ToChar()
			},

			{
				"&ggg;",
				8921.ToChar()
			},

			{
				"&gimel;",
				8503.ToChar()
			},

			{
				"&GJcy;",
				1027.ToChar()
			},

			{
				"&gjcy;",
				1107.ToChar()
			},

			{
				"&gl;",
				8823.ToChar()
			},

			{
				"&gla;",
				10917.ToChar()
			},

			{
				"&glE;",
				10898.ToChar()
			},

			{
				"&glj;",
				10916.ToChar()
			},

			{
				"&gnap;",
				10890.ToChar()
			},

			{
				"&gnapprox;",
				10890.ToChar()
			},

			{
				"&gnE;",
				8809.ToChar()
			},

			{
				"&gne;",
				10888.ToChar()
			},

			{
				"&gneq;",
				10888.ToChar()
			},

			{
				"&gneqq;",
				8809.ToChar()
			},

			{
				"&gnsim;",
				8935.ToChar()
			},

			{
				"&grave;",
				96.ToChar()
			},

			{
				"&GreaterEqual;",
				8805.ToChar()
			},

			{
				"&GreaterEqualLess;",
				8923.ToChar()
			},

			{
				"&GreaterFullEqual;",
				8807.ToChar()
			},

			{
				"&GreaterGreater;",
				10914.ToChar()
			},

			{
				"&GreaterLess;",
				8823.ToChar()
			},

			{
				"&GreaterSlantEqual;",
				10878.ToChar()
			},

			{
				"&GreaterTilde;",
				8819.ToChar()
			},

			{
				"&gscr;",
				8458.ToChar()
			},

			{
				"&gsim;",
				8819.ToChar()
			},

			{
				"&gsime;",
				10894.ToChar()
			},

			{
				"&gsiml;",
				10896.ToChar()
			},

			{
				"&GT;",
				62.ToChar()
			},

			{
				"&Gt;",
				8811.ToChar()
			},

			{
				"&gt;",
				62.ToChar()
			},

			{
				"&gtcc;",
				10919.ToChar()
			},

			{
				"&gtcir;",
				10874.ToChar()
			},

			{
				"&gtdot;",
				8919.ToChar()
			},

			{
				"&gtlPar;",
				10645.ToChar()
			},

			{
				"&gtquest;",
				10876.ToChar()
			},

			{
				"&gtrapprox;",
				10886.ToChar()
			},

			{
				"&gtrarr;",
				10616.ToChar()
			},

			{
				"&gtrdot;",
				8919.ToChar()
			},

			{
				"&gtreqless;",
				8923.ToChar()
			},

			{
				"&gtreqqless;",
				10892.ToChar()
			},

			{
				"&gtrless;",
				8823.ToChar()
			},

			{
				"&gtrsim;",
				8819.ToChar()
			},

			{
				"&gvertneqq;",
				8809.ToChar()
			},

			{
				"&gvnE;",
				8809.ToChar()
			},

			{
				"&Hacek;",
				711.ToChar()
			},

			{
				"&hairsp;",
				8202.ToChar()
			},

			{
				"&half;",
				189.ToChar()
			},

			{
				"&hamilt;",
				8459.ToChar()
			},

			{
				"&HARDcy;",
				1066.ToChar()
			},

			{
				"&hardcy;",
				1098.ToChar()
			},

			{
				"&hArr;",
				8660.ToChar()
			},

			{
				"&harr;",
				8596.ToChar()
			},

			{
				"&harrcir;",
				10568.ToChar()
			},

			{
				"&harrw;",
				8621.ToChar()
			},

			{
				"&Hat;",
				94.ToChar()
			},

			{
				"&hbar;",
				8463.ToChar()
			},

			{
				"&Hcirc;",
				292.ToChar()
			},

			{
				"&hcirc;",
				293.ToChar()
			},

			{
				"&hearts;",
				9829.ToChar()
			},

			{
				"&heartsuit;",
				9829.ToChar()
			},

			{
				"&hellip;",
				8230.ToChar()
			},

			{
				"&hercon;",
				8889.ToChar()
			},

			{
				"&Hfr;",
				8460.ToChar()
			},

			{
				"&HilbertSpace;",
				8459.ToChar()
			},

			{
				"&hksearow;",
				10533.ToChar()
			},

			{
				"&hkswarow;",
				10534.ToChar()
			},

			{
				"&hoarr;",
				8703.ToChar()
			},

			{
				"&homtht;",
				8763.ToChar()
			},

			{
				"&hookleftarrow;",
				8617.ToChar()
			},

			{
				"&hookrightarrow;",
				8618.ToChar()
			},

			{
				"&Hopf;",
				8461.ToChar()
			},

			{
				"&horbar;",
				8213.ToChar()
			},

			{
				"&HorizontalLine;",
				9472.ToChar()
			},

			{
				"&Hscr;",
				8459.ToChar()
			},

			{
				"&hslash;",
				8463.ToChar()
			},

			{
				"&Hstrok;",
				294.ToChar()
			},

			{
				"&hstrok;",
				295.ToChar()
			},

			{
				"&HumpDownHump;",
				8782.ToChar()
			},

			{
				"&HumpEqual;",
				8783.ToChar()
			},

			{
				"&hybull;",
				8259.ToChar()
			},

			{
				"&hyphen;",
				8208.ToChar()
			},

			{
				"&Iacute;",
				205.ToChar()
			},

			{
				"&iacute;",
				237.ToChar()
			},

			{
				"&ic;",
				8291.ToChar()
			},

			{
				"&Icirc;",
				206.ToChar()
			},

			{
				"&icirc;",
				238.ToChar()
			},

			{
				"&Icy;",
				1048.ToChar()
			},

			{
				"&icy;",
				1080.ToChar()
			},

			{
				"&Idot;",
				304.ToChar()
			},

			{
				"&IEcy;",
				1045.ToChar()
			},

			{
				"&iecy;",
				1077.ToChar()
			},

			{
				"&iexcl;",
				161.ToChar()
			},

			{
				"&iff;",
				8660.ToChar()
			},

			{
				"&Ifr;",
				8465.ToChar()
			},

			{
				"&Igrave;",
				204.ToChar()
			},

			{
				"&igrave;",
				236.ToChar()
			},

			{
				"&ii;",
				8520.ToChar()
			},

			{
				"&iiiint;",
				10764.ToChar()
			},

			{
				"&iiint;",
				8749.ToChar()
			},

			{
				"&iinfin;",
				10716.ToChar()
			},

			{
				"&iiota;",
				8489.ToChar()
			},

			{
				"&IJlig;",
				306.ToChar()
			},

			{
				"&ijlig;",
				307.ToChar()
			},

			{
				"&Im;",
				8465.ToChar()
			},

			{
				"&Imacr;",
				298.ToChar()
			},

			{
				"&imacr;",
				299.ToChar()
			},

			{
				"&image;",
				8465.ToChar()
			},

			{
				"&ImaginaryI;",
				8520.ToChar()
			},

			{
				"&imagline;",
				8464.ToChar()
			},

			{
				"&imagpart;",
				8465.ToChar()
			},

			{
				"&imath;",
				305.ToChar()
			},

			{
				"&imof;",
				8887.ToChar()
			},

			{
				"&imped;",
				437.ToChar()
			},

			{
				"&Implies;",
				8658.ToChar()
			},

			{
				"&in;",
				8712.ToChar()
			},

			{
				"&incare;",
				8453.ToChar()
			},

			{
				"&infin;",
				8734.ToChar()
			},

			{
				"&infintie;",
				10717.ToChar()
			},

			{
				"&inodot;",
				305.ToChar()
			},

			{
				"&Int;",
				8748.ToChar()
			},

			{
				"&int;",
				8747.ToChar()
			},

			{
				"&intcal;",
				8890.ToChar()
			},

			{
				"&integers;",
				8484.ToChar()
			},

			{
				"&Integral;",
				8747.ToChar()
			},

			{
				"&intercal;",
				8890.ToChar()
			},

			{
				"&Intersection;",
				8898.ToChar()
			},

			{
				"&intlarhk;",
				10775.ToChar()
			},

			{
				"&intprod;",
				10812.ToChar()
			},

			{
				"&InvisibleComma;",
				8291.ToChar()
			},

			{
				"&InvisibleTimes;",
				8290.ToChar()
			},

			{
				"&IOcy;",
				1025.ToChar()
			},

			{
				"&iocy;",
				1105.ToChar()
			},

			{
				"&Iogon;",
				302.ToChar()
			},

			{
				"&iogon;",
				303.ToChar()
			},

			{
				"&Iota;",
				921.ToChar()
			},

			{
				"&iota;",
				953.ToChar()
			},

			{
				"&iprod;",
				10812.ToChar()
			},

			{
				"&iquest;",
				191.ToChar()
			},

			{
				"&Iscr;",
				8464.ToChar()
			},

			{
				"&isin;",
				8712.ToChar()
			},

			{
				"&isindot;",
				8949.ToChar()
			},

			{
				"&isinE;",
				8953.ToChar()
			},

			{
				"&isins;",
				8948.ToChar()
			},

			{
				"&isinsv;",
				8947.ToChar()
			},

			{
				"&isinv;",
				8712.ToChar()
			},

			{
				"&it;",
				8290.ToChar()
			},

			{
				"&Itilde;",
				296.ToChar()
			},

			{
				"&itilde;",
				297.ToChar()
			},

			{
				"&Iukcy;",
				1030.ToChar()
			},

			{
				"&iukcy;",
				1110.ToChar()
			},

			{
				"&Iuml;",
				207.ToChar()
			},

			{
				"&iuml;",
				239.ToChar()
			},

			{
				"&Jcirc;",
				308.ToChar()
			},

			{
				"&jcirc;",
				309.ToChar()
			},

			{
				"&Jcy;",
				1049.ToChar()
			},

			{
				"&jcy;",
				1081.ToChar()
			},

			{
				"&jmath;",
				567.ToChar()
			},

			{
				"&Jsercy;",
				1032.ToChar()
			},

			{
				"&jsercy;",
				1112.ToChar()
			},

			{
				"&Jukcy;",
				1028.ToChar()
			},

			{
				"&jukcy;",
				1108.ToChar()
			},

			{
				"&Kappa;",
				922.ToChar()
			},

			{
				"&kappa;",
				954.ToChar()
			},

			{
				"&kappav;",
				1008.ToChar()
			},

			{
				"&Kcedil;",
				310.ToChar()
			},

			{
				"&kcedil;",
				311.ToChar()
			},

			{
				"&Kcy;",
				1050.ToChar()
			},

			{
				"&kcy;",
				1082.ToChar()
			},

			{
				"&kgreen;",
				312.ToChar()
			},

			{
				"&KHcy;",
				1061.ToChar()
			},

			{
				"&khcy;",
				1093.ToChar()
			},

			{
				"&KJcy;",
				1036.ToChar()
			},

			{
				"&kjcy;",
				1116.ToChar()
			},

			{
				"&lAarr;",
				8666.ToChar()
			},

			{
				"&Lacute;",
				313.ToChar()
			},

			{
				"&lacute;",
				314.ToChar()
			},

			{
				"&laemptyv;",
				10676.ToChar()
			},

			{
				"&lagran;",
				8466.ToChar()
			},

			{
				"&Lambda;",
				923.ToChar()
			},

			{
				"&lambda;",
				955.ToChar()
			},

			{
				"&Lang;",
				10218.ToChar()
			},

			{
				"&lang;",
				10216.ToChar()
			},

			{
				"&langd;",
				10641.ToChar()
			},

			{
				"&langle;",
				10216.ToChar()
			},

			{
				"&lap;",
				10885.ToChar()
			},

			{
				"&Laplacetrf;",
				8466.ToChar()
			},

			{
				"&laquo;",
				171.ToChar()
			},

			{
				"&Larr;",
				8606.ToChar()
			},

			{
				"&lArr;",
				8656.ToChar()
			},

			{
				"&larr;",
				8592.ToChar()
			},

			{
				"&larrb;",
				8676.ToChar()
			},

			{
				"&larrbfs;",
				10527.ToChar()
			},

			{
				"&larrfs;",
				10525.ToChar()
			},

			{
				"&larrhk;",
				8617.ToChar()
			},

			{
				"&larrlp;",
				8619.ToChar()
			},

			{
				"&larrpl;",
				10553.ToChar()
			},

			{
				"&larrsim;",
				10611.ToChar()
			},

			{
				"&larrtl;",
				8610.ToChar()
			},

			{
				"&lat;",
				10923.ToChar()
			},

			{
				"&lAtail;",
				10523.ToChar()
			},

			{
				"&latail;",
				10521.ToChar()
			},

			{
				"&late;",
				10925.ToChar()
			},

			{
				"&lates;",
				10925.ToChar()
			},

			{
				"&lBarr;",
				10510.ToChar()
			},

			{
				"&lbarr;",
				10508.ToChar()
			},

			{
				"&lbbrk;",
				10098.ToChar()
			},

			{
				"&lbrace;",
				123.ToChar()
			},

			{
				"&lbrack;",
				91.ToChar()
			},

			{
				"&lbrke;",
				10635.ToChar()
			},

			{
				"&lbrksld;",
				10639.ToChar()
			},

			{
				"&lbrkslu;",
				10637.ToChar()
			},

			{
				"&Lcaron;",
				317.ToChar()
			},

			{
				"&lcaron;",
				318.ToChar()
			},

			{
				"&Lcedil;",
				315.ToChar()
			},

			{
				"&lcedil;",
				316.ToChar()
			},

			{
				"&lceil;",
				8968.ToChar()
			},

			{
				"&lcub;",
				123.ToChar()
			},

			{
				"&Lcy;",
				1051.ToChar()
			},

			{
				"&lcy;",
				1083.ToChar()
			},

			{
				"&ldca;",
				10550.ToChar()
			},

			{
				"&ldquo;",
				8220.ToChar()
			},

			{
				"&ldquor;",
				8222.ToChar()
			},

			{
				"&ldrdhar;",
				10599.ToChar()
			},

			{
				"&ldrushar;",
				10571.ToChar()
			},

			{
				"&ldsh;",
				8626.ToChar()
			},

			{
				"&lE;",
				8806.ToChar()
			},

			{
				"&le;",
				8804.ToChar()
			},

			{
				"&LeftAngleBracket;",
				10216.ToChar()
			},

			{
				"&LeftArrow;",
				8592.ToChar()
			},

			{
				"&Leftarrow;",
				8656.ToChar()
			},

			{
				"&leftarrow;",
				8592.ToChar()
			},

			{
				"&LeftArrowBar;",
				8676.ToChar()
			},

			{
				"&LeftArrowRightArrow;",
				8646.ToChar()
			},

			{
				"&leftarrowtail;",
				8610.ToChar()
			},

			{
				"&LeftCeiling;",
				8968.ToChar()
			},

			{
				"&LeftDoubleBracket;",
				10214.ToChar()
			},

			{
				"&LeftDownTeeVector;",
				10593.ToChar()
			},

			{
				"&LeftDownVector;",
				8643.ToChar()
			},

			{
				"&LeftDownVectorBar;",
				10585.ToChar()
			},

			{
				"&LeftFloor;",
				8970.ToChar()
			},

			{
				"&leftharpoondown;",
				8637.ToChar()
			},

			{
				"&leftharpoonup;",
				8636.ToChar()
			},

			{
				"&leftleftarrows;",
				8647.ToChar()
			},

			{
				"&LeftRightArrow;",
				8596.ToChar()
			},

			{
				"&Leftrightarrow;",
				8660.ToChar()
			},

			{
				"&leftrightarrow;",
				8596.ToChar()
			},

			{
				"&leftrightarrows;",
				8646.ToChar()
			},

			{
				"&leftrightharpoons;",
				8651.ToChar()
			},

			{
				"&leftrightsquigarrow;",
				8621.ToChar()
			},

			{
				"&LeftRightVector;",
				10574.ToChar()
			},

			{
				"&LeftTee;",
				8867.ToChar()
			},

			{
				"&LeftTeeArrow;",
				8612.ToChar()
			},

			{
				"&LeftTeeVector;",
				10586.ToChar()
			},

			{
				"&leftthreetimes;",
				8907.ToChar()
			},

			{
				"&LeftTriangle;",
				8882.ToChar()
			},

			{
				"&LeftTriangleBar;",
				10703.ToChar()
			},

			{
				"&LeftTriangleEqual;",
				8884.ToChar()
			},

			{
				"&LeftUpDownVector;",
				10577.ToChar()
			},

			{
				"&LeftUpTeeVector;",
				10592.ToChar()
			},

			{
				"&LeftUpVector;",
				8639.ToChar()
			},

			{
				"&LeftUpVectorBar;",
				10584.ToChar()
			},

			{
				"&LeftVector;",
				8636.ToChar()
			},

			{
				"&LeftVectorBar;",
				10578.ToChar()
			},

			{
				"&lEg;",
				10891.ToChar()
			},

			{
				"&leg;",
				8922.ToChar()
			},

			{
				"&leq;",
				8804.ToChar()
			},

			{
				"&leqq;",
				8806.ToChar()
			},

			{
				"&leqslant;",
				10877.ToChar()
			},

			{
				"&les;",
				10877.ToChar()
			},

			{
				"&lescc;",
				10920.ToChar()
			},

			{
				"&lesdot;",
				10879.ToChar()
			},

			{
				"&lesdoto;",
				10881.ToChar()
			},

			{
				"&lesdotor;",
				10883.ToChar()
			},

			{
				"&lesg;",
				8922.ToChar()
			},

			{
				"&lesges;",
				10899.ToChar()
			},

			{
				"&lessapprox;",
				10885.ToChar()
			},

			{
				"&lessdot;",
				8918.ToChar()
			},

			{
				"&lesseqgtr;",
				8922.ToChar()
			},

			{
				"&lesseqqgtr;",
				10891.ToChar()
			},

			{
				"&LessEqualGreater;",
				8922.ToChar()
			},

			{
				"&LessFullEqual;",
				8806.ToChar()
			},

			{
				"&LessGreater;",
				8822.ToChar()
			},

			{
				"&lessgtr;",
				8822.ToChar()
			},

			{
				"&LessLess;",
				10913.ToChar()
			},

			{
				"&lesssim;",
				8818.ToChar()
			},

			{
				"&LessSlantEqual;",
				10877.ToChar()
			},

			{
				"&LessTilde;",
				8818.ToChar()
			},

			{
				"&lfisht;",
				10620.ToChar()
			},

			{
				"&lfloor;",
				8970.ToChar()
			},

			{
				"&lg;",
				8822.ToChar()
			},

			{
				"&lgE;",
				10897.ToChar()
			},

			{
				"&lHar;",
				10594.ToChar()
			},

			{
				"&lhard;",
				8637.ToChar()
			},

			{
				"&lharu;",
				8636.ToChar()
			},

			{
				"&lharul;",
				10602.ToChar()
			},

			{
				"&lhblk;",
				9604.ToChar()
			},

			{
				"&LJcy;",
				1033.ToChar()
			},

			{
				"&ljcy;",
				1113.ToChar()
			},

			{
				"&Ll;",
				8920.ToChar()
			},

			{
				"&ll;",
				8810.ToChar()
			},

			{
				"&llarr;",
				8647.ToChar()
			},

			{
				"&llcorner;",
				8990.ToChar()
			},

			{
				"&Lleftarrow;",
				8666.ToChar()
			},

			{
				"&llhard;",
				10603.ToChar()
			},

			{
				"&lltri;",
				9722.ToChar()
			},

			{
				"&Lmidot;",
				319.ToChar()
			},

			{
				"&lmidot;",
				320.ToChar()
			},

			{
				"&lmoust;",
				9136.ToChar()
			},

			{
				"&lmoustache;",
				9136.ToChar()
			},

			{
				"&lnap;",
				10889.ToChar()
			},

			{
				"&lnapprox;",
				10889.ToChar()
			},

			{
				"&lnE;",
				8808.ToChar()
			},

			{
				"&lne;",
				10887.ToChar()
			},

			{
				"&lneq;",
				10887.ToChar()
			},

			{
				"&lneqq;",
				8808.ToChar()
			},

			{
				"&lnsim;",
				8934.ToChar()
			},

			{
				"&loang;",
				10220.ToChar()
			},

			{
				"&loarr;",
				8701.ToChar()
			},

			{
				"&lobrk;",
				10214.ToChar()
			},

			{
				"&LongLeftArrow;",
				10229.ToChar()
			},

			{
				"&Longleftarrow;",
				10232.ToChar()
			},

			{
				"&longleftarrow;",
				10229.ToChar()
			},

			{
				"&LongLeftRightArrow;",
				10231.ToChar()
			},

			{
				"&Longleftrightarrow;",
				10234.ToChar()
			},

			{
				"&longleftrightarrow;",
				10231.ToChar()
			},

			{
				"&longmapsto;",
				10236.ToChar()
			},

			{
				"&LongRightArrow;",
				10230.ToChar()
			},

			{
				"&Longrightarrow;",
				10233.ToChar()
			},

			{
				"&longrightarrow;",
				10230.ToChar()
			},

			{
				"&looparrowleft;",
				8619.ToChar()
			},

			{
				"&looparrowright;",
				8620.ToChar()
			},

			{
				"&lopar;",
				10629.ToChar()
			},

			{
				"&loplus;",
				10797.ToChar()
			},

			{
				"&lotimes;",
				10804.ToChar()
			},

			{
				"&lowast;",
				8727.ToChar()
			},

			{
				"&lowbar;",
				95.ToChar()
			},

			{
				"&LowerLeftArrow;",
				8601.ToChar()
			},

			{
				"&LowerRightArrow;",
				8600.ToChar()
			},

			{
				"&loz;",
				9674.ToChar()
			},

			{
				"&lozenge;",
				9674.ToChar()
			},

			{
				"&lozf;",
				10731.ToChar()
			},

			{
				"&lpar;",
				40.ToChar()
			},

			{
				"&lparlt;",
				10643.ToChar()
			},

			{
				"&lrarr;",
				8646.ToChar()
			},

			{
				"&lrcorner;",
				8991.ToChar()
			},

			{
				"&lrhar;",
				8651.ToChar()
			},

			{
				"&lrhard;",
				10605.ToChar()
			},

			{
				"&lrm;",
				8206.ToChar()
			},

			{
				"&lrtri;",
				8895.ToChar()
			},

			{
				"&lsaquo;",
				8249.ToChar()
			},

			{
				"&Lscr;",
				8466.ToChar()
			},

			{
				"&Lsh;",
				8624.ToChar()
			},

			{
				"&lsh;",
				8624.ToChar()
			},

			{
				"&lsim;",
				8818.ToChar()
			},

			{
				"&lsime;",
				10893.ToChar()
			},

			{
				"&lsimg;",
				10895.ToChar()
			},

			{
				"&lsqb;",
				91.ToChar()
			},

			{
				"&lsquo;",
				8216.ToChar()
			},

			{
				"&lsquor;",
				8218.ToChar()
			},

			{
				"&Lstrok;",
				321.ToChar()
			},

			{
				"&lstrok;",
				322.ToChar()
			},

			{
				"&LT;",
				60.ToChar()
			},

			{
				"&Lt;",
				8810.ToChar()
			},

			{
				"&lt;",
				60.ToChar()
			},

			{
				"&ltcc;",
				10918.ToChar()
			},

			{
				"&ltcir;",
				10873.ToChar()
			},

			{
				"&ltdot;",
				8918.ToChar()
			},

			{
				"&lthree;",
				8907.ToChar()
			},

			{
				"&ltimes;",
				8905.ToChar()
			},

			{
				"&ltlarr;",
				10614.ToChar()
			},

			{
				"&ltquest;",
				10875.ToChar()
			},

			{
				"&ltri;",
				9667.ToChar()
			},

			{
				"&ltrie;",
				8884.ToChar()
			},

			{
				"&ltrif;",
				9666.ToChar()
			},

			{
				"&ltrPar;",
				10646.ToChar()
			},

			{
				"&lurdshar;",
				10570.ToChar()
			},

			{
				"&luruhar;",
				10598.ToChar()
			},

			{
				"&lvertneqq;",
				8808.ToChar()
			},

			{
				"&lvnE;",
				8808.ToChar()
			},

			{
				"&macr;",
				175.ToChar()
			},

			{
				"&male;",
				9794.ToChar()
			},

			{
				"&malt;",
				10016.ToChar()
			},

			{
				"&maltese;",
				10016.ToChar()
			},

			{
				"&Map;",
				10501.ToChar()
			},

			{
				"&map;",
				8614.ToChar()
			},

			{
				"&mapsto;",
				8614.ToChar()
			},

			{
				"&mapstodown;",
				8615.ToChar()
			},

			{
				"&mapstoleft;",
				8612.ToChar()
			},

			{
				"&mapstoup;",
				8613.ToChar()
			},

			{
				"&marker;",
				9646.ToChar()
			},

			{
				"&mcomma;",
				10793.ToChar()
			},

			{
				"&Mcy;",
				1052.ToChar()
			},

			{
				"&mcy;",
				1084.ToChar()
			},

			{
				"&mdash;",
				8212.ToChar()
			},

			{
				"&mDDot;",
				8762.ToChar()
			},

			{
				"&measuredangle;",
				8737.ToChar()
			},

			{
				"&MediumSpace;",
				8287.ToChar()
			},

			{
				"&Mellintrf;",
				8499.ToChar()
			},

			{
				"&mho;",
				8487.ToChar()
			},

			{
				"&micro;",
				181.ToChar()
			},

			{
				"&mid;",
				8739.ToChar()
			},

			{
				"&midast;",
				42.ToChar()
			},

			{
				"&midcir;",
				10992.ToChar()
			},

			{
				"&middot;",
				183.ToChar()
			},

			{
				"&minus;",
				8722.ToChar()
			},

			{
				"&minusb;",
				8863.ToChar()
			},

			{
				"&minusd;",
				8760.ToChar()
			},

			{
				"&minusdu;",
				10794.ToChar()
			},

			{
				"&MinusPlus;",
				8723.ToChar()
			},

			{
				"&mlcp;",
				10971.ToChar()
			},

			{
				"&mldr;",
				8230.ToChar()
			},

			{
				"&mnplus;",
				8723.ToChar()
			},

			{
				"&models;",
				8871.ToChar()
			},

			{
				"&mp;",
				8723.ToChar()
			},

			{
				"&Mscr;",
				8499.ToChar()
			},

			{
				"&mstpos;",
				8766.ToChar()
			},

			{
				"&Mu;",
				924.ToChar()
			},

			{
				"&mu;",
				956.ToChar()
			},

			{
				"&multimap;",
				8888.ToChar()
			},

			{
				"&mumap;",
				8888.ToChar()
			},

			{
				"&nabla;",
				8711.ToChar()
			},

			{
				"&Nacute;",
				323.ToChar()
			},

			{
				"&nacute;",
				324.ToChar()
			},

			{
				"&nang;",
				8736.ToChar()
			},

			{
				"&nap;",
				8777.ToChar()
			},

			{
				"&napE;",
				10864.ToChar()
			},

			{
				"&napid;",
				8779.ToChar()
			},

			{
				"&napos;",
				329.ToChar()
			},

			{
				"&napprox;",
				8777.ToChar()
			},

			{
				"&natur;",
				9838.ToChar()
			},

			{
				"&natural;",
				9838.ToChar()
			},

			{
				"&naturals;",
				8469.ToChar()
			},

			{
				"&nbsp;",
				160.ToChar()
			},

			{
				"&nbump;",
				8782.ToChar()
			},

			{
				"&nbumpe;",
				8783.ToChar()
			},

			{
				"&ncap;",
				10819.ToChar()
			},

			{
				"&Ncaron;",
				327.ToChar()
			},

			{
				"&ncaron;",
				328.ToChar()
			},

			{
				"&Ncedil;",
				325.ToChar()
			},

			{
				"&ncedil;",
				326.ToChar()
			},

			{
				"&ncong;",
				8775.ToChar()
			},

			{
				"&ncongdot;",
				10861.ToChar()
			},

			{
				"&ncup;",
				10818.ToChar()
			},

			{
				"&Ncy;",
				1053.ToChar()
			},

			{
				"&ncy;",
				1085.ToChar()
			},

			{
				"&ndash;",
				8211.ToChar()
			},

			{
				"&ne;",
				8800.ToChar()
			},

			{
				"&nearhk;",
				10532.ToChar()
			},

			{
				"&neArr;",
				8663.ToChar()
			},

			{
				"&nearr;",
				8599.ToChar()
			},

			{
				"&nearrow;",
				8599.ToChar()
			},

			{
				"&nedot;",
				8784.ToChar()
			},

			{
				"&NegativeMediumSpace;",
				8203.ToChar()
			},

			{
				"&NegativeThickSpace;",
				8203.ToChar()
			},

			{
				"&NegativeThinSpace;",
				8203.ToChar()
			},

			{
				"&NegativeVeryThinSpace;",
				8203.ToChar()
			},

			{
				"&nequiv;",
				8802.ToChar()
			},

			{
				"&nesear;",
				10536.ToChar()
			},

			{
				"&nesim;",
				8770.ToChar()
			},

			{
				"&NestedGreaterGreater;",
				8811.ToChar()
			},

			{
				"&NestedLessLess;",
				8810.ToChar()
			},

			{
				"&NewLine;",
				10.ToChar()
			},

			{
				"&nexist;",
				8708.ToChar()
			},

			{
				"&nexists;",
				8708.ToChar()
			},

			{
				"&ngE;",
				8807.ToChar()
			},

			{
				"&nge;",
				8817.ToChar()
			},

			{
				"&ngeq;",
				8817.ToChar()
			},

			{
				"&ngeqq;",
				8807.ToChar()
			},

			{
				"&ngeqslant;",
				10878.ToChar()
			},

			{
				"&nges;",
				10878.ToChar()
			},

			{
				"&nGg;",
				8921.ToChar()
			},

			{
				"&ngsim;",
				8821.ToChar()
			},

			{
				"&nGt;",
				8811.ToChar()
			},

			{
				"&ngt;",
				8815.ToChar()
			},

			{
				"&ngtr;",
				8815.ToChar()
			},

			{
				"&nGtv;",
				8811.ToChar()
			},

			{
				"&nhArr;",
				8654.ToChar()
			},

			{
				"&nharr;",
				8622.ToChar()
			},

			{
				"&nhpar;",
				10994.ToChar()
			},

			{
				"&ni;",
				8715.ToChar()
			},

			{
				"&nis;",
				8956.ToChar()
			},

			{
				"&nisd;",
				8954.ToChar()
			},

			{
				"&niv;",
				8715.ToChar()
			},

			{
				"&NJcy;",
				1034.ToChar()
			},

			{
				"&njcy;",
				1114.ToChar()
			},

			{
				"&nlArr;",
				8653.ToChar()
			},

			{
				"&nlarr;",
				8602.ToChar()
			},

			{
				"&nldr;",
				8229.ToChar()
			},

			{
				"&nlE;",
				8806.ToChar()
			},

			{
				"&nle;",
				8816.ToChar()
			},

			{
				"&nLeftarrow;",
				8653.ToChar()
			},

			{
				"&nleftarrow;",
				8602.ToChar()
			},

			{
				"&nLeftrightarrow;",
				8654.ToChar()
			},

			{
				"&nleftrightarrow;",
				8622.ToChar()
			},

			{
				"&nleq;",
				8816.ToChar()
			},

			{
				"&nleqq;",
				8806.ToChar()
			},

			{
				"&nleqslant;",
				10877.ToChar()
			},

			{
				"&nles;",
				10877.ToChar()
			},

			{
				"&nless;",
				8814.ToChar()
			},

			{
				"&nLl;",
				8920.ToChar()
			},

			{
				"&nlsim;",
				8820.ToChar()
			},

			{
				"&nLt;",
				8810.ToChar()
			},

			{
				"&nlt;",
				8814.ToChar()
			},

			{
				"&nltri;",
				8938.ToChar()
			},

			{
				"&nltrie;",
				8940.ToChar()
			},

			{
				"&nLtv;",
				8810.ToChar()
			},

			{
				"&nmid;",
				8740.ToChar()
			},

			{
				"&NoBreak;",
				8288.ToChar()
			},

			{
				"&NonBreakingSpace;",
				160.ToChar()
			},

			{
				"&Nopf;",
				8469.ToChar()
			},

			{
				"&Not;",
				10988.ToChar()
			},

			{
				"&not;",
				172.ToChar()
			},

			{
				"&NotCongruent;",
				8802.ToChar()
			},

			{
				"&NotCupCap;",
				8813.ToChar()
			},

			{
				"&NotDoubleVerticalBar;",
				8742.ToChar()
			},

			{
				"&NotElement;",
				8713.ToChar()
			},

			{
				"&NotEqual;",
				8800.ToChar()
			},

			{
				"&NotEqualTilde;",
				8770.ToChar()
			},

			{
				"&NotExists;",
				8708.ToChar()
			},

			{
				"&NotGreater;",
				8815.ToChar()
			},

			{
				"&NotGreaterEqual;",
				8817.ToChar()
			},

			{
				"&NotGreaterFullEqual;",
				8807.ToChar()
			},

			{
				"&NotGreaterGreater;",
				8811.ToChar()
			},

			{
				"&NotGreaterLess;",
				8825.ToChar()
			},

			{
				"&NotGreaterSlantEqual;",
				10878.ToChar()
			},

			{
				"&NotGreaterTilde;",
				8821.ToChar()
			},

			{
				"&NotHumpDownHump;",
				8782.ToChar()
			},

			{
				"&NotHumpEqual;",
				8783.ToChar()
			},

			{
				"&notin;",
				8713.ToChar()
			},

			{
				"&notindot;",
				8949.ToChar()
			},

			{
				"&notinE;",
				8953.ToChar()
			},

			{
				"&notinva;",
				8713.ToChar()
			},

			{
				"&notinvb;",
				8951.ToChar()
			},

			{
				"&notinvc;",
				8950.ToChar()
			},

			{
				"&NotLeftTriangle;",
				8938.ToChar()
			},

			{
				"&NotLeftTriangleBar;",
				10703.ToChar()
			},

			{
				"&NotLeftTriangleEqual;",
				8940.ToChar()
			},

			{
				"&NotLess;",
				8814.ToChar()
			},

			{
				"&NotLessEqual;",
				8816.ToChar()
			},

			{
				"&NotLessGreater;",
				8824.ToChar()
			},

			{
				"&NotLessLess;",
				8810.ToChar()
			},

			{
				"&NotLessSlantEqual;",
				10877.ToChar()
			},

			{
				"&NotLessTilde;",
				8820.ToChar()
			},

			{
				"&NotNestedGreaterGreater;",
				10914.ToChar()
			},

			{
				"&NotNestedLessLess;",
				10913.ToChar()
			},

			{
				"&notni;",
				8716.ToChar()
			},

			{
				"&notniva;",
				8716.ToChar()
			},

			{
				"&notnivb;",
				8958.ToChar()
			},

			{
				"&notnivc;",
				8957.ToChar()
			},

			{
				"&NotPrecedes;",
				8832.ToChar()
			},

			{
				"&NotPrecedesEqual;",
				10927.ToChar()
			},

			{
				"&NotPrecedesSlantEqual;",
				8928.ToChar()
			},

			{
				"&NotReverseElement;",
				8716.ToChar()
			},

			{
				"&NotRightTriangle;",
				8939.ToChar()
			},

			{
				"&NotRightTriangleBar;",
				10704.ToChar()
			},

			{
				"&NotRightTriangleEqual;",
				8941.ToChar()
			},

			{
				"&NotSquareSubset;",
				8847.ToChar()
			},

			{
				"&NotSquareSubsetEqual;",
				8930.ToChar()
			},

			{
				"&NotSquareSuperset;",
				8848.ToChar()
			},

			{
				"&NotSquareSupersetEqual;",
				8931.ToChar()
			},

			{
				"&NotSubset;",
				8834.ToChar()
			},

			{
				"&NotSubsetEqual;",
				8840.ToChar()
			},

			{
				"&NotSucceeds;",
				8833.ToChar()
			},

			{
				"&NotSucceedsEqual;",
				10928.ToChar()
			},

			{
				"&NotSucceedsSlantEqual;",
				8929.ToChar()
			},

			{
				"&NotSucceedsTilde;",
				8831.ToChar()
			},

			{
				"&NotSuperset;",
				8835.ToChar()
			},

			{
				"&NotSupersetEqual;",
				8841.ToChar()
			},

			{
				"&NotTilde;",
				8769.ToChar()
			},

			{
				"&NotTildeEqual;",
				8772.ToChar()
			},

			{
				"&NotTildeFullEqual;",
				8775.ToChar()
			},

			{
				"&NotTildeTilde;",
				8777.ToChar()
			},

			{
				"&NotVerticalBar;",
				8740.ToChar()
			},

			{
				"&npar;",
				8742.ToChar()
			},

			{
				"&nparallel;",
				8742.ToChar()
			},

			{
				"&nparsl;",
				11005.ToChar()
			},

			{
				"&npart;",
				8706.ToChar()
			},

			{
				"&npolint;",
				10772.ToChar()
			},

			{
				"&npr;",
				8832.ToChar()
			},

			{
				"&nprcue;",
				8928.ToChar()
			},

			{
				"&npre;",
				10927.ToChar()
			},

			{
				"&nprec;",
				8832.ToChar()
			},

			{
				"&npreceq;",
				10927.ToChar()
			},

			{
				"&nrArr;",
				8655.ToChar()
			},

			{
				"&nrarr;",
				8603.ToChar()
			},

			{
				"&nrarrc;",
				10547.ToChar()
			},

			{
				"&nrarrw;",
				8605.ToChar()
			},

			{
				"&nRightarrow;",
				8655.ToChar()
			},

			{
				"&nrightarrow;",
				8603.ToChar()
			},

			{
				"&nrtri;",
				8939.ToChar()
			},

			{
				"&nrtrie;",
				8941.ToChar()
			},

			{
				"&nsc;",
				8833.ToChar()
			},

			{
				"&nsccue;",
				8929.ToChar()
			},

			{
				"&nsce;",
				10928.ToChar()
			},

			{
				"&nshortmid;",
				8740.ToChar()
			},

			{
				"&nshortparallel;",
				8742.ToChar()
			},

			{
				"&nsim;",
				8769.ToChar()
			},

			{
				"&nsime;",
				8772.ToChar()
			},

			{
				"&nsimeq;",
				8772.ToChar()
			},

			{
				"&nsmid;",
				8740.ToChar()
			},

			{
				"&nspar;",
				8742.ToChar()
			},

			{
				"&nsqsube;",
				8930.ToChar()
			},

			{
				"&nsqsupe;",
				8931.ToChar()
			},

			{
				"&nsub;",
				8836.ToChar()
			},

			{
				"&nsubE;",
				10949.ToChar()
			},

			{
				"&nsube;",
				8840.ToChar()
			},

			{
				"&nsubset;",
				8834.ToChar()
			},

			{
				"&nsubseteq;",
				8840.ToChar()
			},

			{
				"&nsubseteqq;",
				10949.ToChar()
			},

			{
				"&nsucc;",
				8833.ToChar()
			},

			{
				"&nsucceq;",
				10928.ToChar()
			},

			{
				"&nsup;",
				8837.ToChar()
			},

			{
				"&nsupE;",
				10950.ToChar()
			},

			{
				"&nsupe;",
				8841.ToChar()
			},

			{
				"&nsupset;",
				8835.ToChar()
			},

			{
				"&nsupseteq;",
				8841.ToChar()
			},

			{
				"&nsupseteqq;",
				10950.ToChar()
			},

			{
				"&ntgl;",
				8825.ToChar()
			},

			{
				"&Ntilde;",
				209.ToChar()
			},

			{
				"&ntilde;",
				241.ToChar()
			},

			{
				"&ntlg;",
				8824.ToChar()
			},

			{
				"&ntriangleleft;",
				8938.ToChar()
			},

			{
				"&ntrianglelefteq;",
				8940.ToChar()
			},

			{
				"&ntriangleright;",
				8939.ToChar()
			},

			{
				"&ntrianglerighteq;",
				8941.ToChar()
			},

			{
				"&Nu;",
				925.ToChar()
			},

			{
				"&nu;",
				957.ToChar()
			},

			{
				"&num;",
				35.ToChar()
			},

			{
				"&numero;",
				8470.ToChar()
			},

			{
				"&numsp;",
				8199.ToChar()
			},

			{
				"&nvap;",
				8781.ToChar()
			},

			{
				"&nVDash;",
				8879.ToChar()
			},

			{
				"&nVdash;",
				8878.ToChar()
			},

			{
				"&nvDash;",
				8877.ToChar()
			},

			{
				"&nvdash;",
				8876.ToChar()
			},

			{
				"&nvge;",
				8805.ToChar()
			},

			{
				"&nvgt;",
				62.ToChar()
			},

			{
				"&nvHarr;",
				10500.ToChar()
			},

			{
				"&nvinfin;",
				10718.ToChar()
			},

			{
				"&nvlArr;",
				10498.ToChar()
			},

			{
				"&nvle;",
				8804.ToChar()
			},

			{
				"&nvlt;",
				60.ToChar()
			},

			{
				"&nvltrie;",
				8884.ToChar()
			},

			{
				"&nvrArr;",
				10499.ToChar()
			},

			{
				"&nvrtrie;",
				8885.ToChar()
			},

			{
				"&nvsim;",
				8764.ToChar()
			},

			{
				"&nwarhk;",
				10531.ToChar()
			},

			{
				"&nwArr;",
				8662.ToChar()
			},

			{
				"&nwarr;",
				8598.ToChar()
			},

			{
				"&nwarrow;",
				8598.ToChar()
			},

			{
				"&nwnear;",
				10535.ToChar()
			},

			{
				"&Oacute;",
				211.ToChar()
			},

			{
				"&oacute;",
				243.ToChar()
			},

			{
				"&oast;",
				8859.ToChar()
			},

			{
				"&ocir;",
				8858.ToChar()
			},

			{
				"&Ocirc;",
				212.ToChar()
			},

			{
				"&ocirc;",
				244.ToChar()
			},

			{
				"&Ocy;",
				1054.ToChar()
			},

			{
				"&ocy;",
				1086.ToChar()
			},

			{
				"&odash;",
				8861.ToChar()
			},

			{
				"&Odblac;",
				336.ToChar()
			},

			{
				"&odblac;",
				337.ToChar()
			},

			{
				"&odiv;",
				10808.ToChar()
			},

			{
				"&odot;",
				8857.ToChar()
			},

			{
				"&odsold;",
				10684.ToChar()
			},

			{
				"&OElig;",
				338.ToChar()
			},

			{
				"&oelig;",
				339.ToChar()
			},

			{
				"&ofcir;",
				10687.ToChar()
			},

			{
				"&ogon;",
				731.ToChar()
			},

			{
				"&Ograve;",
				210.ToChar()
			},

			{
				"&ograve;",
				242.ToChar()
			},

			{
				"&ogt;",
				10689.ToChar()
			},

			{
				"&ohbar;",
				10677.ToChar()
			},

			{
				"&ohm;",
				937.ToChar()
			},

			{
				"&oint;",
				8750.ToChar()
			},

			{
				"&olarr;",
				8634.ToChar()
			},

			{
				"&olcir;",
				10686.ToChar()
			},

			{
				"&olcross;",
				10683.ToChar()
			},

			{
				"&oline;",
				8254.ToChar()
			},

			{
				"&olt;",
				10688.ToChar()
			},

			{
				"&Omacr;",
				332.ToChar()
			},

			{
				"&omacr;",
				333.ToChar()
			},

			{
				"&Omega;",
				937.ToChar()
			},

			{
				"&omega;",
				969.ToChar()
			},

			{
				"&Omicron;",
				927.ToChar()
			},

			{
				"&omicron;",
				959.ToChar()
			},

			{
				"&omid;",
				10678.ToChar()
			},

			{
				"&ominus;",
				8854.ToChar()
			},

			{
				"&opar;",
				10679.ToChar()
			},

			{
				"&OpenCurlyDoubleQuote;",
				8220.ToChar()
			},

			{
				"&OpenCurlyQuote;",
				8216.ToChar()
			},

			{
				"&operp;",
				10681.ToChar()
			},

			{
				"&oplus;",
				8853.ToChar()
			},

			{
				"&Or;",
				10836.ToChar()
			},

			{
				"&or;",
				8744.ToChar()
			},

			{
				"&orarr;",
				8635.ToChar()
			},

			{
				"&ord;",
				10845.ToChar()
			},

			{
				"&order;",
				8500.ToChar()
			},

			{
				"&orderof;",
				8500.ToChar()
			},

			{
				"&ordf;",
				170.ToChar()
			},

			{
				"&ordm;",
				186.ToChar()
			},

			{
				"&origof;",
				8886.ToChar()
			},

			{
				"&oror;",
				10838.ToChar()
			},

			{
				"&orslope;",
				10839.ToChar()
			},

			{
				"&orv;",
				10843.ToChar()
			},

			{
				"&oS;",
				9416.ToChar()
			},

			{
				"&oscr;",
				8500.ToChar()
			},

			{
				"&Oslash;",
				216.ToChar()
			},

			{
				"&oslash;",
				248.ToChar()
			},

			{
				"&osol;",
				8856.ToChar()
			},

			{
				"&Otilde;",
				213.ToChar()
			},

			{
				"&otilde;",
				245.ToChar()
			},

			{
				"&Otimes;",
				10807.ToChar()
			},

			{
				"&otimes;",
				8855.ToChar()
			},

			{
				"&otimesas;",
				10806.ToChar()
			},

			{
				"&Ouml;",
				214.ToChar()
			},

			{
				"&ouml;",
				246.ToChar()
			},

			{
				"&ovbar;",
				9021.ToChar()
			},

			{
				"&OverBar;",
				8254.ToChar()
			},

			{
				"&OverBrace;",
				9182.ToChar()
			},

			{
				"&OverBracket;",
				9140.ToChar()
			},

			{
				"&OverParenthesis;",
				9180.ToChar()
			},

			{
				"&par;",
				8741.ToChar()
			},

			{
				"&para;",
				182.ToChar()
			},

			{
				"&parallel;",
				8741.ToChar()
			},

			{
				"&parsim;",
				10995.ToChar()
			},

			{
				"&parsl;",
				11005.ToChar()
			},

			{
				"&part;",
				8706.ToChar()
			},

			{
				"&PartialD;",
				8706.ToChar()
			},

			{
				"&Pcy;",
				1055.ToChar()
			},

			{
				"&pcy;",
				1087.ToChar()
			},

			{
				"&percnt;",
				37.ToChar()
			},

			{
				"&period;",
				46.ToChar()
			},

			{
				"&permil;",
				8240.ToChar()
			},

			{
				"&perp;",
				8869.ToChar()
			},

			{
				"&pertenk;",
				8241.ToChar()
			},

			{
				"&Phi;",
				934.ToChar()
			},

			{
				"&phi;",
				966.ToChar()
			},

			{
				"&phiv;",
				981.ToChar()
			},

			{
				"&phmmat;",
				8499.ToChar()
			},

			{
				"&phone;",
				9742.ToChar()
			},

			{
				"&Pi;",
				928.ToChar()
			},

			{
				"&pi;",
				960.ToChar()
			},

			{
				"&pitchfork;",
				8916.ToChar()
			},

			{
				"&piv;",
				982.ToChar()
			},

			{
				"&planck;",
				8463.ToChar()
			},

			{
				"&planckh;",
				8462.ToChar()
			},

			{
				"&plankv;",
				8463.ToChar()
			},

			{
				"&plus;",
				43.ToChar()
			},

			{
				"&plusacir;",
				10787.ToChar()
			},

			{
				"&plusb;",
				8862.ToChar()
			},

			{
				"&pluscir;",
				10786.ToChar()
			},

			{
				"&plusdo;",
				8724.ToChar()
			},

			{
				"&plusdu;",
				10789.ToChar()
			},

			{
				"&pluse;",
				10866.ToChar()
			},

			{
				"&PlusMinus;",
				177.ToChar()
			},

			{
				"&plusmn;",
				177.ToChar()
			},

			{
				"&plussim;",
				10790.ToChar()
			},

			{
				"&plustwo;",
				10791.ToChar()
			},

			{
				"&pm;",
				177.ToChar()
			},

			{
				"&Poincareplane;",
				8460.ToChar()
			},

			{
				"&pointint;",
				10773.ToChar()
			},

			{
				"&Popf;",
				8473.ToChar()
			},

			{
				"&pound;",
				163.ToChar()
			},

			{
				"&Pr;",
				10939.ToChar()
			},

			{
				"&pr;",
				8826.ToChar()
			},

			{
				"&prap;",
				10935.ToChar()
			},

			{
				"&prcue;",
				8828.ToChar()
			},

			{
				"&prE;",
				10931.ToChar()
			},

			{
				"&pre;",
				10927.ToChar()
			},

			{
				"&prec;",
				8826.ToChar()
			},

			{
				"&precapprox;",
				10935.ToChar()
			},

			{
				"&preccurlyeq;",
				8828.ToChar()
			},

			{
				"&Precedes;",
				8826.ToChar()
			},

			{
				"&PrecedesEqual;",
				10927.ToChar()
			},

			{
				"&PrecedesSlantEqual;",
				8828.ToChar()
			},

			{
				"&PrecedesTilde;",
				8830.ToChar()
			},

			{
				"&preceq;",
				10927.ToChar()
			},

			{
				"&precnapprox;",
				10937.ToChar()
			},

			{
				"&precneqq;",
				10933.ToChar()
			},

			{
				"&precnsim;",
				8936.ToChar()
			},

			{
				"&precsim;",
				8830.ToChar()
			},

			{
				"&Prime;",
				8243.ToChar()
			},

			{
				"&prime;",
				8242.ToChar()
			},

			{
				"&primes;",
				8473.ToChar()
			},

			{
				"&prnap;",
				10937.ToChar()
			},

			{
				"&prnE;",
				10933.ToChar()
			},

			{
				"&prnsim;",
				8936.ToChar()
			},

			{
				"&prod;",
				8719.ToChar()
			},

			{
				"&Product;",
				8719.ToChar()
			},

			{
				"&profalar;",
				9006.ToChar()
			},

			{
				"&profline;",
				8978.ToChar()
			},

			{
				"&profsurf;",
				8979.ToChar()
			},

			{
				"&prop;",
				8733.ToChar()
			},

			{
				"&Proportion;",
				8759.ToChar()
			},

			{
				"&Proportional;",
				8733.ToChar()
			},

			{
				"&propto;",
				8733.ToChar()
			},

			{
				"&prsim;",
				8830.ToChar()
			},

			{
				"&prurel;",
				8880.ToChar()
			},

			{
				"&Psi;",
				936.ToChar()
			},

			{
				"&psi;",
				968.ToChar()
			},

			{
				"&puncsp;",
				8200.ToChar()
			},

			{
				"&qint;",
				10764.ToChar()
			},

			{
				"&Qopf;",
				8474.ToChar()
			},

			{
				"&qprime;",
				8279.ToChar()
			},

			{
				"&quaternions;",
				8461.ToChar()
			},

			{
				"&quatint;",
				10774.ToChar()
			},

			{
				"&quest;",
				63.ToChar()
			},

			{
				"&questeq;",
				8799.ToChar()
			},

			{
				"&QUOT;",
				34.ToChar()
			},

			{
				"&quot;",
				34.ToChar()
			},

			{
				"&rAarr;",
				8667.ToChar()
			},

			{
				"&race;",
				8765.ToChar()
			},

			{
				"&Racute;",
				340.ToChar()
			},

			{
				"&racute;",
				341.ToChar()
			},

			{
				"&radic;",
				8730.ToChar()
			},

			{
				"&raemptyv;",
				10675.ToChar()
			},

			{
				"&Rang;",
				10219.ToChar()
			},

			{
				"&rang;",
				10217.ToChar()
			},

			{
				"&rangd;",
				10642.ToChar()
			},

			{
				"&range;",
				10661.ToChar()
			},

			{
				"&rangle;",
				10217.ToChar()
			},

			{
				"&raquo;",
				187.ToChar()
			},

			{
				"&Rarr;",
				8608.ToChar()
			},

			{
				"&rArr;",
				8658.ToChar()
			},

			{
				"&rarr;",
				8594.ToChar()
			},

			{
				"&rarrap;",
				10613.ToChar()
			},

			{
				"&rarrb;",
				8677.ToChar()
			},

			{
				"&rarrbfs;",
				10528.ToChar()
			},

			{
				"&rarrc;",
				10547.ToChar()
			},

			{
				"&rarrfs;",
				10526.ToChar()
			},

			{
				"&rarrhk;",
				8618.ToChar()
			},

			{
				"&rarrlp;",
				8620.ToChar()
			},

			{
				"&rarrpl;",
				10565.ToChar()
			},

			{
				"&rarrsim;",
				10612.ToChar()
			},

			{
				"&Rarrtl;",
				10518.ToChar()
			},

			{
				"&rarrtl;",
				8611.ToChar()
			},

			{
				"&rarrw;",
				8605.ToChar()
			},

			{
				"&rAtail;",
				10524.ToChar()
			},

			{
				"&ratail;",
				10522.ToChar()
			},

			{
				"&ratio;",
				8758.ToChar()
			},

			{
				"&rationals;",
				8474.ToChar()
			},

			{
				"&RBarr;",
				10512.ToChar()
			},

			{
				"&rBarr;",
				10511.ToChar()
			},

			{
				"&rbarr;",
				10509.ToChar()
			},

			{
				"&rbbrk;",
				10099.ToChar()
			},

			{
				"&rbrace;",
				125.ToChar()
			},

			{
				"&rbrack;",
				93.ToChar()
			},

			{
				"&rbrke;",
				10636.ToChar()
			},

			{
				"&rbrksld;",
				10638.ToChar()
			},

			{
				"&rbrkslu;",
				10640.ToChar()
			},

			{
				"&Rcaron;",
				344.ToChar()
			},

			{
				"&rcaron;",
				345.ToChar()
			},

			{
				"&Rcedil;",
				342.ToChar()
			},

			{
				"&rcedil;",
				343.ToChar()
			},

			{
				"&rceil;",
				8969.ToChar()
			},

			{
				"&rcub;",
				125.ToChar()
			},

			{
				"&Rcy;",
				1056.ToChar()
			},

			{
				"&rcy;",
				1088.ToChar()
			},

			{
				"&rdca;",
				10551.ToChar()
			},

			{
				"&rdldhar;",
				10601.ToChar()
			},

			{
				"&rdquo;",
				8221.ToChar()
			},

			{
				"&rdquor;",
				8221.ToChar()
			},

			{
				"&rdsh;",
				8627.ToChar()
			},

			{
				"&Re;",
				8476.ToChar()
			},

			{
				"&real;",
				8476.ToChar()
			},

			{
				"&realine;",
				8475.ToChar()
			},

			{
				"&realpart;",
				8476.ToChar()
			},

			{
				"&reals;",
				8477.ToChar()
			},

			{
				"&rect;",
				9645.ToChar()
			},

			{
				"&REG;",
				174.ToChar()
			},

			{
				"&reg;",
				174.ToChar()
			},

			{
				"&ReverseElement;",
				8715.ToChar()
			},

			{
				"&ReverseEquilibrium;",
				8651.ToChar()
			},

			{
				"&ReverseUpEquilibrium;",
				10607.ToChar()
			},

			{
				"&rfisht;",
				10621.ToChar()
			},

			{
				"&rfloor;",
				8971.ToChar()
			},

			{
				"&Rfr;",
				8476.ToChar()
			},

			{
				"&rHar;",
				10596.ToChar()
			},

			{
				"&rhard;",
				8641.ToChar()
			},

			{
				"&rharu;",
				8640.ToChar()
			},

			{
				"&rharul;",
				10604.ToChar()
			},

			{
				"&Rho;",
				929.ToChar()
			},

			{
				"&rho;",
				961.ToChar()
			},

			{
				"&rhov;",
				1009.ToChar()
			},

			{
				"&RightAngleBracket;",
				10217.ToChar()
			},

			{
				"&RightArrow;",
				8594.ToChar()
			},

			{
				"&Rightarrow;",
				8658.ToChar()
			},

			{
				"&rightarrow;",
				8594.ToChar()
			},

			{
				"&RightArrowBar;",
				8677.ToChar()
			},

			{
				"&RightArrowLeftArrow;",
				8644.ToChar()
			},

			{
				"&rightarrowtail;",
				8611.ToChar()
			},

			{
				"&RightCeiling;",
				8969.ToChar()
			},

			{
				"&RightDoubleBracket;",
				10215.ToChar()
			},

			{
				"&RightDownTeeVector;",
				10589.ToChar()
			},

			{
				"&RightDownVector;",
				8642.ToChar()
			},

			{
				"&RightDownVectorBar;",
				10581.ToChar()
			},

			{
				"&RightFloor;",
				8971.ToChar()
			},

			{
				"&rightharpoondown;",
				8641.ToChar()
			},

			{
				"&rightharpoonup;",
				8640.ToChar()
			},

			{
				"&rightleftarrows;",
				8644.ToChar()
			},

			{
				"&rightleftharpoons;",
				8652.ToChar()
			},

			{
				"&rightrightarrows;",
				8649.ToChar()
			},

			{
				"&rightsquigarrow;",
				8605.ToChar()
			},

			{
				"&RightTee;",
				8866.ToChar()
			},

			{
				"&RightTeeArrow;",
				8614.ToChar()
			},

			{
				"&RightTeeVector;",
				10587.ToChar()
			},

			{
				"&rightthreetimes;",
				8908.ToChar()
			},

			{
				"&RightTriangle;",
				8883.ToChar()
			},

			{
				"&RightTriangleBar;",
				10704.ToChar()
			},

			{
				"&RightTriangleEqual;",
				8885.ToChar()
			},

			{
				"&RightUpDownVector;",
				10575.ToChar()
			},

			{
				"&RightUpTeeVector;",
				10588.ToChar()
			},

			{
				"&RightUpVector;",
				8638.ToChar()
			},

			{
				"&RightUpVectorBar;",
				10580.ToChar()
			},

			{
				"&RightVector;",
				8640.ToChar()
			},

			{
				"&RightVectorBar;",
				10579.ToChar()
			},

			{
				"&ring;",
				730.ToChar()
			},

			{
				"&risingdotseq;",
				8787.ToChar()
			},

			{
				"&rlarr;",
				8644.ToChar()
			},

			{
				"&rlhar;",
				8652.ToChar()
			},

			{
				"&rlm;",
				8207.ToChar()
			},

			{
				"&rmoust;",
				9137.ToChar()
			},

			{
				"&rmoustache;",
				9137.ToChar()
			},

			{
				"&rnmid;",
				10990.ToChar()
			},

			{
				"&roang;",
				10221.ToChar()
			},

			{
				"&roarr;",
				8702.ToChar()
			},

			{
				"&robrk;",
				10215.ToChar()
			},

			{
				"&ropar;",
				10630.ToChar()
			},

			{
				"&Ropf;",
				8477.ToChar()
			},

			{
				"&roplus;",
				10798.ToChar()
			},

			{
				"&rotimes;",
				10805.ToChar()
			},

			{
				"&RoundImplies;",
				10608.ToChar()
			},

			{
				"&rpar;",
				41.ToChar()
			},

			{
				"&rpargt;",
				10644.ToChar()
			},

			{
				"&rppolint;",
				10770.ToChar()
			},

			{
				"&rrarr;",
				8649.ToChar()
			},

			{
				"&Rrightarrow;",
				8667.ToChar()
			},

			{
				"&rsaquo;",
				8250.ToChar()
			},

			{
				"&Rscr;",
				8475.ToChar()
			},

			{
				"&Rsh;",
				8625.ToChar()
			},

			{
				"&rsh;",
				8625.ToChar()
			},

			{
				"&rsqb;",
				93.ToChar()
			},

			{
				"&rsquo;",
				8217.ToChar()
			},

			{
				"&rsquor;",
				8217.ToChar()
			},

			{
				"&rthree;",
				8908.ToChar()
			},

			{
				"&rtimes;",
				8906.ToChar()
			},

			{
				"&rtri;",
				9657.ToChar()
			},

			{
				"&rtrie;",
				8885.ToChar()
			},

			{
				"&rtrif;",
				9656.ToChar()
			},

			{
				"&rtriltri;",
				10702.ToChar()
			},

			{
				"&RuleDelayed;",
				10740.ToChar()
			},

			{
				"&ruluhar;",
				10600.ToChar()
			},

			{
				"&rx;",
				8478.ToChar()
			},

			{
				"&Sacute;",
				346.ToChar()
			},

			{
				"&sacute;",
				347.ToChar()
			},

			{
				"&sbquo;",
				8218.ToChar()
			},

			{
				"&Sc;",
				10940.ToChar()
			},

			{
				"&sc;",
				8827.ToChar()
			},

			{
				"&scap;",
				10936.ToChar()
			},

			{
				"&Scaron;",
				352.ToChar()
			},

			{
				"&scaron;",
				353.ToChar()
			},

			{
				"&sccue;",
				8829.ToChar()
			},

			{
				"&scE;",
				10932.ToChar()
			},

			{
				"&sce;",
				10928.ToChar()
			},

			{
				"&Scedil;",
				350.ToChar()
			},

			{
				"&scedil;",
				351.ToChar()
			},

			{
				"&Scirc;",
				348.ToChar()
			},

			{
				"&scirc;",
				349.ToChar()
			},

			{
				"&scnap;",
				10938.ToChar()
			},

			{
				"&scnE;",
				10934.ToChar()
			},

			{
				"&scnsim;",
				8937.ToChar()
			},

			{
				"&scpolint;",
				10771.ToChar()
			},

			{
				"&scsim;",
				8831.ToChar()
			},

			{
				"&Scy;",
				1057.ToChar()
			},

			{
				"&scy;",
				1089.ToChar()
			},

			{
				"&sdot;",
				8901.ToChar()
			},

			{
				"&sdotb;",
				8865.ToChar()
			},

			{
				"&sdote;",
				10854.ToChar()
			},

			{
				"&searhk;",
				10533.ToChar()
			},

			{
				"&seArr;",
				8664.ToChar()
			},

			{
				"&searr;",
				8600.ToChar()
			},

			{
				"&searrow;",
				8600.ToChar()
			},

			{
				"&sect;",
				167.ToChar()
			},

			{
				"&semi;",
				59.ToChar()
			},

			{
				"&seswar;",
				10537.ToChar()
			},

			{
				"&setminus;",
				8726.ToChar()
			},

			{
				"&setmn;",
				8726.ToChar()
			},

			{
				"&sext;",
				10038.ToChar()
			},

			{
				"&sfrown;",
				8994.ToChar()
			},

			{
				"&sharp;",
				9839.ToChar()
			},

			{
				"&SHCHcy;",
				1065.ToChar()
			},

			{
				"&shchcy;",
				1097.ToChar()
			},

			{
				"&SHcy;",
				1064.ToChar()
			},

			{
				"&shcy;",
				1096.ToChar()
			},

			{
				"&ShortDownArrow;",
				8595.ToChar()
			},

			{
				"&ShortLeftArrow;",
				8592.ToChar()
			},

			{
				"&shortmid;",
				8739.ToChar()
			},

			{
				"&shortparallel;",
				8741.ToChar()
			},

			{
				"&ShortRightArrow;",
				8594.ToChar()
			},

			{
				"&ShortUpArrow;",
				8593.ToChar()
			},

			{
				"&shy;",
				173.ToChar()
			},

			{
				"&Sigma;",
				931.ToChar()
			},

			{
				"&sigma;",
				963.ToChar()
			},

			{
				"&sigmaf;",
				962.ToChar()
			},

			{
				"&sigmav;",
				962.ToChar()
			},

			{
				"&sim;",
				8764.ToChar()
			},

			{
				"&simdot;",
				10858.ToChar()
			},

			{
				"&sime;",
				8771.ToChar()
			},

			{
				"&simeq;",
				8771.ToChar()
			},

			{
				"&simg;",
				10910.ToChar()
			},

			{
				"&simgE;",
				10912.ToChar()
			},

			{
				"&siml;",
				10909.ToChar()
			},

			{
				"&simlE;",
				10911.ToChar()
			},

			{
				"&simne;",
				8774.ToChar()
			},

			{
				"&simplus;",
				10788.ToChar()
			},

			{
				"&simrarr;",
				10610.ToChar()
			},

			{
				"&slarr;",
				8592.ToChar()
			},

			{
				"&SmallCircle;",
				8728.ToChar()
			},

			{
				"&smallsetminus;",
				8726.ToChar()
			},

			{
				"&smashp;",
				10803.ToChar()
			},

			{
				"&smeparsl;",
				10724.ToChar()
			},

			{
				"&smid;",
				8739.ToChar()
			},

			{
				"&smile;",
				8995.ToChar()
			},

			{
				"&smt;",
				10922.ToChar()
			},

			{
				"&smte;",
				10924.ToChar()
			},

			{
				"&smtes;",
				10924.ToChar()
			},

			{
				"&SOFTcy;",
				1068.ToChar()
			},

			{
				"&softcy;",
				1100.ToChar()
			},

			{
				"&sol;",
				47.ToChar()
			},

			{
				"&solb;",
				10692.ToChar()
			},

			{
				"&solbar;",
				9023.ToChar()
			},

			{
				"&spades;",
				9824.ToChar()
			},

			{
				"&spadesuit;",
				9824.ToChar()
			},

			{
				"&spar;",
				8741.ToChar()
			},

			{
				"&sqcap;",
				8851.ToChar()
			},

			{
				"&sqcaps;",
				8851.ToChar()
			},

			{
				"&sqcup;",
				8852.ToChar()
			},

			{
				"&sqcups;",
				8852.ToChar()
			},

			{
				"&Sqrt;",
				8730.ToChar()
			},

			{
				"&sqsub;",
				8847.ToChar()
			},

			{
				"&sqsube;",
				8849.ToChar()
			},

			{
				"&sqsubset;",
				8847.ToChar()
			},

			{
				"&sqsubseteq;",
				8849.ToChar()
			},

			{
				"&sqsup;",
				8848.ToChar()
			},

			{
				"&sqsupe;",
				8850.ToChar()
			},

			{
				"&sqsupset;",
				8848.ToChar()
			},

			{
				"&sqsupseteq;",
				8850.ToChar()
			},

			{
				"&squ;",
				9633.ToChar()
			},

			{
				"&Square;",
				9633.ToChar()
			},

			{
				"&square;",
				9633.ToChar()
			},

			{
				"&SquareIntersection;",
				8851.ToChar()
			},

			{
				"&SquareSubset;",
				8847.ToChar()
			},

			{
				"&SquareSubsetEqual;",
				8849.ToChar()
			},

			{
				"&SquareSuperset;",
				8848.ToChar()
			},

			{
				"&SquareSupersetEqual;",
				8850.ToChar()
			},

			{
				"&SquareUnion;",
				8852.ToChar()
			},

			{
				"&squarf;",
				9642.ToChar()
			},

			{
				"&squf;",
				9642.ToChar()
			},

			{
				"&srarr;",
				8594.ToChar()
			},

			{
				"&ssetmn;",
				8726.ToChar()
			},

			{
				"&ssmile;",
				8995.ToChar()
			},

			{
				"&sstarf;",
				8902.ToChar()
			},

			{
				"&Star;",
				8902.ToChar()
			},

			{
				"&star;",
				9734.ToChar()
			},

			{
				"&starf;",
				9733.ToChar()
			},

			{
				"&straightepsilon;",
				1013.ToChar()
			},

			{
				"&straightphi;",
				981.ToChar()
			},

			{
				"&strns;",
				175.ToChar()
			},

			{
				"&Sub;",
				8912.ToChar()
			},

			{
				"&sub;",
				8834.ToChar()
			},

			{
				"&subdot;",
				10941.ToChar()
			},

			{
				"&subE;",
				10949.ToChar()
			},

			{
				"&sube;",
				8838.ToChar()
			},

			{
				"&subedot;",
				10947.ToChar()
			},

			{
				"&submult;",
				10945.ToChar()
			},

			{
				"&subnE;",
				10955.ToChar()
			},

			{
				"&subne;",
				8842.ToChar()
			},

			{
				"&subplus;",
				10943.ToChar()
			},

			{
				"&subrarr;",
				10617.ToChar()
			},

			{
				"&Subset;",
				8912.ToChar()
			},

			{
				"&subset;",
				8834.ToChar()
			},

			{
				"&subseteq;",
				8838.ToChar()
			},

			{
				"&subseteqq;",
				10949.ToChar()
			},

			{
				"&SubsetEqual;",
				8838.ToChar()
			},

			{
				"&subsetneq;",
				8842.ToChar()
			},

			{
				"&subsetneqq;",
				10955.ToChar()
			},

			{
				"&subsim;",
				10951.ToChar()
			},

			{
				"&subsub;",
				10965.ToChar()
			},

			{
				"&subsup;",
				10963.ToChar()
			},

			{
				"&succ;",
				8827.ToChar()
			},

			{
				"&succapprox;",
				10936.ToChar()
			},

			{
				"&succcurlyeq;",
				8829.ToChar()
			},

			{
				"&Succeeds;",
				8827.ToChar()
			},

			{
				"&SucceedsEqual;",
				10928.ToChar()
			},

			{
				"&SucceedsSlantEqual;",
				8829.ToChar()
			},

			{
				"&SucceedsTilde;",
				8831.ToChar()
			},

			{
				"&succeq;",
				10928.ToChar()
			},

			{
				"&succnapprox;",
				10938.ToChar()
			},

			{
				"&succneqq;",
				10934.ToChar()
			},

			{
				"&succnsim;",
				8937.ToChar()
			},

			{
				"&succsim;",
				8831.ToChar()
			},

			{
				"&SuchThat;",
				8715.ToChar()
			},

			{
				"&Sum;",
				8721.ToChar()
			},

			{
				"&sum;",
				8721.ToChar()
			},

			{
				"&sung;",
				9834.ToChar()
			},

			{
				"&Sup;",
				8913.ToChar()
			},

			{
				"&sup;",
				8835.ToChar()
			},

			{
				"&sup1;",
				185.ToChar()
			},

			{
				"&sup2;",
				178.ToChar()
			},

			{
				"&sup3;",
				179.ToChar()
			},

			{
				"&supdot;",
				10942.ToChar()
			},

			{
				"&supdsub;",
				10968.ToChar()
			},

			{
				"&supE;",
				10950.ToChar()
			},

			{
				"&supe;",
				8839.ToChar()
			},

			{
				"&supedot;",
				10948.ToChar()
			},

			{
				"&Superset;",
				8835.ToChar()
			},

			{
				"&SupersetEqual;",
				8839.ToChar()
			},

			{
				"&suphsol;",
				10185.ToChar()
			},

			{
				"&suphsub;",
				10967.ToChar()
			},

			{
				"&suplarr;",
				10619.ToChar()
			},

			{
				"&supmult;",
				10946.ToChar()
			},

			{
				"&supnE;",
				10956.ToChar()
			},

			{
				"&supne;",
				8843.ToChar()
			},

			{
				"&supplus;",
				10944.ToChar()
			},

			{
				"&Supset;",
				8913.ToChar()
			},

			{
				"&supset;",
				8835.ToChar()
			},

			{
				"&supseteq;",
				8839.ToChar()
			},

			{
				"&supseteqq;",
				10950.ToChar()
			},

			{
				"&supsetneq;",
				8843.ToChar()
			},

			{
				"&supsetneqq;",
				10956.ToChar()
			},

			{
				"&supsim;",
				10952.ToChar()
			},

			{
				"&supsub;",
				10964.ToChar()
			},

			{
				"&supsup;",
				10966.ToChar()
			},

			{
				"&swarhk;",
				10534.ToChar()
			},

			{
				"&swArr;",
				8665.ToChar()
			},

			{
				"&swarr;",
				8601.ToChar()
			},

			{
				"&swarrow;",
				8601.ToChar()
			},

			{
				"&swnwar;",
				10538.ToChar()
			},

			{
				"&szlig;",
				223.ToChar()
			},

			{
				"&Tab;",
				9.ToChar()
			},

			{
				"&target;",
				8982.ToChar()
			},

			{
				"&Tau;",
				932.ToChar()
			},

			{
				"&tau;",
				964.ToChar()
			},

			{
				"&tbrk;",
				9140.ToChar()
			},

			{
				"&Tcaron;",
				356.ToChar()
			},

			{
				"&tcaron;",
				357.ToChar()
			},

			{
				"&Tcedil;",
				354.ToChar()
			},

			{
				"&tcedil;",
				355.ToChar()
			},

			{
				"&Tcy;",
				1058.ToChar()
			},

			{
				"&tcy;",
				1090.ToChar()
			},

			{
				"&tdot;",
				8411.ToChar()
			},

			{
				"&telrec;",
				8981.ToChar()
			},

			{
				"&there4;",
				8756.ToChar()
			},

			{
				"&Therefore;",
				8756.ToChar()
			},

			{
				"&therefore;",
				8756.ToChar()
			},

			{
				"&Theta;",
				920.ToChar()
			},

			{
				"&theta;",
				952.ToChar()
			},

			{
				"&thetasym;",
				977.ToChar()
			},

			{
				"&thetav;",
				977.ToChar()
			},

			{
				"&thickapprox;",
				8776.ToChar()
			},

			{
				"&thicksim;",
				8764.ToChar()
			},

			{
				"&ThickSpace;",
				8287.ToChar()
			},

			{
				"&thinsp;",
				8201.ToChar()
			},

			{
				"&ThinSpace;",
				8201.ToChar()
			},

			{
				"&thkap;",
				8776.ToChar()
			},

			{
				"&thksim;",
				8764.ToChar()
			},

			{
				"&THORN;",
				222.ToChar()
			},

			{
				"&thorn;",
				254.ToChar()
			},

			{
				"&Tilde;",
				8764.ToChar()
			},

			{
				"&tilde;",
				732.ToChar()
			},

			{
				"&TildeEqual;",
				8771.ToChar()
			},

			{
				"&TildeFullEqual;",
				8773.ToChar()
			},

			{
				"&TildeTilde;",
				8776.ToChar()
			},

			{
				"&times;",
				215.ToChar()
			},

			{
				"&timesb;",
				8864.ToChar()
			},

			{
				"&timesbar;",
				10801.ToChar()
			},

			{
				"&timesd;",
				10800.ToChar()
			},

			{
				"&tint;",
				8749.ToChar()
			},

			{
				"&toea;",
				10536.ToChar()
			},

			{
				"&top;",
				8868.ToChar()
			},

			{
				"&topbot;",
				9014.ToChar()
			},

			{
				"&topcir;",
				10993.ToChar()
			},

			{
				"&topfork;",
				10970.ToChar()
			},

			{
				"&tosa;",
				10537.ToChar()
			},

			{
				"&tprime;",
				8244.ToChar()
			},

			{
				"&TRADE;",
				8482.ToChar()
			},

			{
				"&trade;",
				8482.ToChar()
			},

			{
				"&triangle;",
				9653.ToChar()
			},

			{
				"&triangledown;",
				9663.ToChar()
			},

			{
				"&triangleleft;",
				9667.ToChar()
			},

			{
				"&trianglelefteq;",
				8884.ToChar()
			},

			{
				"&triangleq;",
				8796.ToChar()
			},

			{
				"&triangleright;",
				9657.ToChar()
			},

			{
				"&trianglerighteq;",
				8885.ToChar()
			},

			{
				"&tridot;",
				9708.ToChar()
			},

			{
				"&trie;",
				8796.ToChar()
			},

			{
				"&triminus;",
				10810.ToChar()
			},

			{
				"&TripleDot;",
				8411.ToChar()
			},

			{
				"&triplus;",
				10809.ToChar()
			},

			{
				"&trisb;",
				10701.ToChar()
			},

			{
				"&tritime;",
				10811.ToChar()
			},

			{
				"&trpezium;",
				9186.ToChar()
			},

			{
				"&TScy;",
				1062.ToChar()
			},

			{
				"&tscy;",
				1094.ToChar()
			},

			{
				"&TSHcy;",
				1035.ToChar()
			},

			{
				"&tshcy;",
				1115.ToChar()
			},

			{
				"&Tstrok;",
				358.ToChar()
			},

			{
				"&tstrok;",
				359.ToChar()
			},

			{
				"&twixt;",
				8812.ToChar()
			},

			{
				"&twoheadleftarrow;",
				8606.ToChar()
			},

			{
				"&twoheadrightarrow;",
				8608.ToChar()
			},

			{
				"&Uacute;",
				218.ToChar()
			},

			{
				"&uacute;",
				250.ToChar()
			},

			{
				"&Uarr;",
				8607.ToChar()
			},

			{
				"&uArr;",
				8657.ToChar()
			},

			{
				"&uarr;",
				8593.ToChar()
			},

			{
				"&Uarrocir;",
				10569.ToChar()
			},

			{
				"&Ubrcy;",
				1038.ToChar()
			},

			{
				"&ubrcy;",
				1118.ToChar()
			},

			{
				"&Ubreve;",
				364.ToChar()
			},

			{
				"&ubreve;",
				365.ToChar()
			},

			{
				"&Ucirc;",
				219.ToChar()
			},

			{
				"&ucirc;",
				251.ToChar()
			},

			{
				"&Ucy;",
				1059.ToChar()
			},

			{
				"&ucy;",
				1091.ToChar()
			},

			{
				"&udarr;",
				8645.ToChar()
			},

			{
				"&Udblac;",
				368.ToChar()
			},

			{
				"&udblac;",
				369.ToChar()
			},

			{
				"&udhar;",
				10606.ToChar()
			},

			{
				"&ufisht;",
				10622.ToChar()
			},

			{
				"&Ugrave;",
				217.ToChar()
			},

			{
				"&ugrave;",
				249.ToChar()
			},

			{
				"&uHar;",
				10595.ToChar()
			},

			{
				"&uharl;",
				8639.ToChar()
			},

			{
				"&uharr;",
				8638.ToChar()
			},

			{
				"&uhblk;",
				9600.ToChar()
			},

			{
				"&ulcorn;",
				8988.ToChar()
			},

			{
				"&ulcorner;",
				8988.ToChar()
			},

			{
				"&ulcrop;",
				8975.ToChar()
			},

			{
				"&ultri;",
				9720.ToChar()
			},

			{
				"&Umacr;",
				362.ToChar()
			},

			{
				"&umacr;",
				363.ToChar()
			},

			{
				"&uml;",
				168.ToChar()
			},

			{
				"&UnderBar;",
				95.ToChar()
			},

			{
				"&UnderBrace;",
				9183.ToChar()
			},

			{
				"&UnderBracket;",
				9141.ToChar()
			},

			{
				"&UnderParenthesis;",
				9181.ToChar()
			},

			{
				"&Union;",
				8899.ToChar()
			},

			{
				"&UnionPlus;",
				8846.ToChar()
			},

			{
				"&Uogon;",
				370.ToChar()
			},

			{
				"&uogon;",
				371.ToChar()
			},

			{
				"&UpArrow;",
				8593.ToChar()
			},

			{
				"&Uparrow;",
				8657.ToChar()
			},

			{
				"&uparrow;",
				8593.ToChar()
			},

			{
				"&UpArrowBar;",
				10514.ToChar()
			},

			{
				"&UpArrowDownArrow;",
				8645.ToChar()
			},

			{
				"&UpDownArrow;",
				8597.ToChar()
			},

			{
				"&Updownarrow;",
				8661.ToChar()
			},

			{
				"&updownarrow;",
				8597.ToChar()
			},

			{
				"&UpEquilibrium;",
				10606.ToChar()
			},

			{
				"&upharpoonleft;",
				8639.ToChar()
			},

			{
				"&upharpoonright;",
				8638.ToChar()
			},

			{
				"&uplus;",
				8846.ToChar()
			},

			{
				"&UpperLeftArrow;",
				8598.ToChar()
			},

			{
				"&UpperRightArrow;",
				8599.ToChar()
			},

			{
				"&Upsi;",
				978.ToChar()
			},

			{
				"&upsi;",
				965.ToChar()
			},

			{
				"&upsih;",
				978.ToChar()
			},

			{
				"&Upsilon;",
				933.ToChar()
			},

			{
				"&upsilon;",
				965.ToChar()
			},

			{
				"&UpTee;",
				8869.ToChar()
			},

			{
				"&UpTeeArrow;",
				8613.ToChar()
			},

			{
				"&upuparrows;",
				8648.ToChar()
			},

			{
				"&urcorn;",
				8989.ToChar()
			},

			{
				"&urcorner;",
				8989.ToChar()
			},

			{
				"&urcrop;",
				8974.ToChar()
			},

			{
				"&Uring;",
				366.ToChar()
			},

			{
				"&uring;",
				367.ToChar()
			},

			{
				"&urtri;",
				9721.ToChar()
			},

			{
				"&utdot;",
				8944.ToChar()
			},

			{
				"&Utilde;",
				360.ToChar()
			},

			{
				"&utilde;",
				361.ToChar()
			},

			{
				"&utri;",
				9653.ToChar()
			},

			{
				"&utrif;",
				9652.ToChar()
			},

			{
				"&uuarr;",
				8648.ToChar()
			},

			{
				"&Uuml;",
				220.ToChar()
			},

			{
				"&uuml;",
				252.ToChar()
			},

			{
				"&uwangle;",
				10663.ToChar()
			},

			{
				"&vangrt;",
				10652.ToChar()
			},

			{
				"&varepsilon;",
				1013.ToChar()
			},

			{
				"&varkappa;",
				1008.ToChar()
			},

			{
				"&varnothing;",
				8709.ToChar()
			},

			{
				"&varphi;",
				981.ToChar()
			},

			{
				"&varpi;",
				982.ToChar()
			},

			{
				"&varpropto;",
				8733.ToChar()
			},

			{
				"&vArr;",
				8661.ToChar()
			},

			{
				"&varr;",
				8597.ToChar()
			},

			{
				"&varrho;",
				1009.ToChar()
			},

			{
				"&varsigma;",
				962.ToChar()
			},

			{
				"&varsubsetneq;",
				8842.ToChar()
			},

			{
				"&varsubsetneqq;",
				10955.ToChar()
			},

			{
				"&varsupsetneq;",
				8843.ToChar()
			},

			{
				"&varsupsetneqq;",
				10956.ToChar()
			},

			{
				"&vartheta;",
				977.ToChar()
			},

			{
				"&vartriangleleft;",
				8882.ToChar()
			},

			{
				"&vartriangleright;",
				8883.ToChar()
			},

			{
				"&Vbar;",
				10987.ToChar()
			},

			{
				"&vBar;",
				10984.ToChar()
			},

			{
				"&vBarv;",
				10985.ToChar()
			},

			{
				"&Vcy;",
				1042.ToChar()
			},

			{
				"&vcy;",
				1074.ToChar()
			},

			{
				"&VDash;",
				8875.ToChar()
			},

			{
				"&Vdash;",
				8873.ToChar()
			},

			{
				"&vDash;",
				8872.ToChar()
			},

			{
				"&vdash;",
				8866.ToChar()
			},

			{
				"&Vdashl;",
				10982.ToChar()
			},

			{
				"&Vee;",
				8897.ToChar()
			},

			{
				"&vee;",
				8744.ToChar()
			},

			{
				"&veebar;",
				8891.ToChar()
			},

			{
				"&veeeq;",
				8794.ToChar()
			},

			{
				"&vellip;",
				8942.ToChar()
			},

			{
				"&Verbar;",
				8214.ToChar()
			},

			{
				"&verbar;",
				124.ToChar()
			},

			{
				"&Vert;",
				8214.ToChar()
			},

			{
				"&vert;",
				124.ToChar()
			},

			{
				"&VerticalBar;",
				8739.ToChar()
			},

			{
				"&VerticalLine;",
				124.ToChar()
			},

			{
				"&VerticalSeparator;",
				10072.ToChar()
			},

			{
				"&VerticalTilde;",
				8768.ToChar()
			},

			{
				"&VeryThinSpace;",
				8202.ToChar()
			},

			{
				"&vltri;",
				8882.ToChar()
			},

			{
				"&vnsub;",
				8834.ToChar()
			},

			{
				"&vnsup;",
				8835.ToChar()
			},

			{
				"&vprop;",
				8733.ToChar()
			},

			{
				"&vrtri;",
				8883.ToChar()
			},

			{
				"&vsubnE;",
				10955.ToChar()
			},

			{
				"&vsubne;",
				8842.ToChar()
			},

			{
				"&vsupnE;",
				10956.ToChar()
			},

			{
				"&vsupne;",
				8843.ToChar()
			},

			{
				"&Vvdash;",
				8874.ToChar()
			},

			{
				"&vzigzag;",
				10650.ToChar()
			},

			{
				"&Wcirc;",
				372.ToChar()
			},

			{
				"&wcirc;",
				373.ToChar()
			},

			{
				"&wedbar;",
				10847.ToChar()
			},

			{
				"&Wedge;",
				8896.ToChar()
			},

			{
				"&wedge;",
				8743.ToChar()
			},

			{
				"&wedgeq;",
				8793.ToChar()
			},

			{
				"&weierp;",
				8472.ToChar()
			},

			{
				"&wp;",
				8472.ToChar()
			},

			{
				"&wr;",
				8768.ToChar()
			},

			{
				"&wreath;",
				8768.ToChar()
			},

			{
				"&xcap;",
				8898.ToChar()
			},

			{
				"&xcirc;",
				9711.ToChar()
			},

			{
				"&xcup;",
				8899.ToChar()
			},

			{
				"&xdtri;",
				9661.ToChar()
			},

			{
				"&xhArr;",
				10234.ToChar()
			},

			{
				"&xharr;",
				10231.ToChar()
			},

			{
				"&Xi;",
				926.ToChar()
			},

			{
				"&xi;",
				958.ToChar()
			},

			{
				"&xlArr;",
				10232.ToChar()
			},

			{
				"&xlarr;",
				10229.ToChar()
			},

			{
				"&xmap;",
				10236.ToChar()
			},

			{
				"&xnis;",
				8955.ToChar()
			},

			{
				"&xodot;",
				10752.ToChar()
			},

			{
				"&xoplus;",
				10753.ToChar()
			},

			{
				"&xotime;",
				10754.ToChar()
			},

			{
				"&xrArr;",
				10233.ToChar()
			},

			{
				"&xrarr;",
				10230.ToChar()
			},

			{
				"&xsqcup;",
				10758.ToChar()
			},

			{
				"&xuplus;",
				10756.ToChar()
			},

			{
				"&xutri;",
				9651.ToChar()
			},

			{
				"&xvee;",
				8897.ToChar()
			},

			{
				"&xwedge;",
				8896.ToChar()
			},

			{
				"&Yacute;",
				221.ToChar()
			},

			{
				"&yacute;",
				253.ToChar()
			},

			{
				"&YAcy;",
				1071.ToChar()
			},

			{
				"&yacy;",
				1103.ToChar()
			},

			{
				"&Ycirc;",
				374.ToChar()
			},

			{
				"&ycirc;",
				375.ToChar()
			},

			{
				"&Ycy;",
				1067.ToChar()
			},

			{
				"&ycy;",
				1099.ToChar()
			},

			{
				"&yen;",
				165.ToChar()
			},

			{
				"&YIcy;",
				1031.ToChar()
			},

			{
				"&yicy;",
				1111.ToChar()
			},

			{
				"&YUcy;",
				1070.ToChar()
			},

			{
				"&yucy;",
				1102.ToChar()
			},

			{
				"&Yuml;",
				376.ToChar()
			},

			{
				"&yuml;",
				255.ToChar()
			},

			{
				"&Zacute;",
				377.ToChar()
			},

			{
				"&zacute;",
				378.ToChar()
			},

			{
				"&Zcaron;",
				381.ToChar()
			},

			{
				"&zcaron;",
				382.ToChar()
			},

			{
				"&Zcy;",
				1047.ToChar()
			},

			{
				"&zcy;",
				1079.ToChar()
			},

			{
				"&Zdot;",
				379.ToChar()
			},

			{
				"&zdot;",
				380.ToChar()
			},

			{
				"&zeetrf;",
				8488.ToChar()
			},

			{
				"&ZeroWidthSpace;",
				8203.ToChar()
			},

			{
				"&Zeta;",
				918.ToChar()
			},

			{
				"&zeta;",
				950.ToChar()
			},

			{
				"&Zfr;",
				8488.ToChar()
			},

			{
				"&ZHcy;",
				1046.ToChar()
			},

			{
				"&zhcy;",
				1078.ToChar()
			},

			{
				"&zigrarr;",
				8669.ToChar()
			},

			{
				"&Zopf;",
				8484.ToChar()
			},

			{
				"&zwj;",
				8205.ToChar()
			},

			{
				"&zwnj;",
				8204.ToChar()
			}
		};
		public static List<Command> ParseCommands(this string commandsString)
		{
			List<Command> list = new List<Command>();
			if (string.IsNullOrEmpty(commandsString))
			{
				return list;
			}
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			int num = 0;
			Command command = new Command();
			for (int i = 0; i < commandsString.Length; i++)
			{
				char c = commandsString[i];
				if (flag)
				{
					if (c == '"')
					{
						flag = false;
					}
				}
				else
				{
					if (flag2)
					{
						if (c == '\'')
						{
							flag2 = false;
						}
					}
					else
					{
						if (c == '"')
						{
							flag = true;
						}
						else
						{
							if (c == '\'')
							{
								flag2 = true;
							}
							else
							{
								if (c == '(')
								{
									flag3 = true;
									command.Name = commandsString.Substring(num, i - num).Trim();
									num = i + 1;
								}
								else
								{
									if (c == ')')
									{
										flag3 = false;
										string item = commandsString.Substring(num, i - num).Trim();
										command.Args.Add(item);
										num = i + 1;
										int num2 = commandsString.IndexOf(',', num);
										if (num2 == -1)
										{
											num2 = commandsString.Length;
										}
										command.Suffix = commandsString.Substring(num, num2 - num);
										num = num2;
									}
									else
									{
										if (c == ',')
										{
											if (flag3)
											{
												string item2 = commandsString.Substring(num, i - num).Trim();
												command.Args.Add(item2);
												num = i + 1;
											}
											else
											{
												if (command.Name == null)
												{
													command.Name = commandsString.Substring(num, i - num).Trim();
												}
												list.Add(command);
												command = new Command();
												num = i + 1;
											}
										}
									}
								}
							}
						}
					}
				}
			}
			string text = commandsString.Substring(num, commandsString.Length - num);
			if (!string.IsNullOrEmpty(text))
			{
				command.Name = text.Trim();
			}
			if (!string.IsNullOrEmpty(command.Name))
			{
				list.Add(command);
			}
			return list;
		}
		public static string ConvertHtmlCodes(this string html)
		{
			return StringUtils.StripHtmlUnicodeRegEx.Replace(html, new MatchEvaluator(StringUtils.ConvertHtmlCodeToCharacter));
		}
		private static string ConvertHtmlCodeToCharacter(Match match)
		{
			if (match.Groups[1].Success)
			{
				string value = match.Groups[3].Value;
				ushort num;
				if (match.Groups[2].Success)
				{
					if (!ushort.TryParse(value, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out num))
					{
						return match.Value;
					}
				}
				else
				{
					if (!ushort.TryParse(value, out num))
					{
						return match.Value;
					}
				}
				char c = (char)num;
				return c.ToString(CultureInfo.InvariantCulture);
			}
			string result;
			if (StringUtils.HtmlCharacterCodes.TryGetValue(match.Value, out result))
			{
				return result;
			}
			return match.Value;
		}
		public static string ToChar(this int codePoint)
		{
			return Convert.ToChar(codePoint).ToString(CultureInfo.InvariantCulture);
		}
	}
}
